/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ /* * Do not modify this file. This file is generated from the ssm-2014-11-06.normal.json service model. */ using System; using System.Runtime.ExceptionServices; using System.Threading; using System.Threading.Tasks; using System.Collections.Generic; using System.Net; using Amazon.SimpleSystemsManagement.Model; using Amazon.SimpleSystemsManagement.Model.Internal.MarshallTransformations; using Amazon.SimpleSystemsManagement.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.SimpleSystemsManagement { ///

/// Implementation for accessing SimpleSystemsManagement /// /// 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 /// ///

/// /// For information about each of the capabilities that comprise Systems Manager, see /// Systems /// Manager capabilities in the Amazon Web Services Systems Manager User Guide. /// ///
/// /// For details about predefined runbooks for Automation, a capability of Amazon Web Services /// Systems Manager, see the Systems /// Manager Automation runbook reference . /// ///
/// /// For information about AppConfig, a capability of Systems Manager, see the AppConfig /// User Guide and the AppConfig /// API Reference . /// ///
/// /// For information about Incident Manager, a capability of Systems Manager, see the /// Systems Manager /// Incident Manager User Guide and the Systems /// Manager Incident Manager API Reference . /// ///

///

public partial class AmazonSimpleSystemsManagementClient : AmazonServiceClient, IAmazonSimpleSystemsManagement { private static IServiceMetadata serviceMetadata = new AmazonSimpleSystemsManagementMetadata(); #region Constructors ///

/// Constructs AmazonSimpleSystemsManagementClient with the credentials loaded from the application's /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. /// /// Example App.config with credentials set. ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

public AmazonSimpleSystemsManagementClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonSimpleSystemsManagementConfig()) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The region to connect. public AmazonSimpleSystemsManagementClient(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonSimpleSystemsManagementConfig{RegionEndpoint = region}) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The AmazonSimpleSystemsManagementClient Configuration Object public AmazonSimpleSystemsManagementClient(AmazonSimpleSystemsManagementConfig config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} ///

/// Constructs AmazonSimpleSystemsManagementClient with AWS Credentials ///

/// AWS Credentials public AmazonSimpleSystemsManagementClient(AWSCredentials credentials) : this(credentials, new AmazonSimpleSystemsManagementConfig()) { } ///

/// Constructs AmazonSimpleSystemsManagementClient with AWS Credentials ///

/// AWS Credentials /// The region to connect. public AmazonSimpleSystemsManagementClient(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonSimpleSystemsManagementConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonSimpleSystemsManagementClient with AWS Credentials and an /// AmazonSimpleSystemsManagementClient Configuration object. ///

/// AWS Credentials /// The AmazonSimpleSystemsManagementClient Configuration Object public AmazonSimpleSystemsManagementClient(AWSCredentials credentials, AmazonSimpleSystemsManagementConfig clientConfig) : base(credentials, clientConfig) { } ///

/// Constructs AmazonSimpleSystemsManagementClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key public AmazonSimpleSystemsManagementClient(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonSimpleSystemsManagementConfig()) { } ///

/// Constructs AmazonSimpleSystemsManagementClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonSimpleSystemsManagementClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonSimpleSystemsManagementConfig() {RegionEndpoint=region}) { } ///

/// Constructs AmazonSimpleSystemsManagementClient with AWS Access Key ID, AWS Secret Key and an /// AmazonSimpleSystemsManagementClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// The AmazonSimpleSystemsManagementClient Configuration Object public AmazonSimpleSystemsManagementClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonSimpleSystemsManagementConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } ///

/// Constructs AmazonSimpleSystemsManagementClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonSimpleSystemsManagementClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonSimpleSystemsManagementConfig()) { } ///

/// Constructs AmazonSimpleSystemsManagementClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The region to connect. public AmazonSimpleSystemsManagementClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonSimpleSystemsManagementConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonSimpleSystemsManagementClient with AWS Access Key ID, AWS Secret Key and an /// AmazonSimpleSystemsManagementClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonSimpleSystemsManagementClient Configuration Object public AmazonSimpleSystemsManagementClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonSimpleSystemsManagementConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig) { } #endregion #if AWS_ASYNC_ENUMERABLES_API private ISimpleSystemsManagementPaginatorFactory _paginators; ///

/// Paginators for the service ///

public ISimpleSystemsManagementPaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new SimpleSystemsManagementPaginatorFactory(this); } return this._paginators; } } #endif #region Overrides ///

/// Creates the signer for the service. ///

protected override AbstractAWSSigner CreateSigner() { return new AWS4Signer(); } ///

/// Customizes the runtime pipeline. ///

/// Runtime pipeline for the current client. protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline) { pipeline.RemoveHandler(); pipeline.AddHandlerAfter(new AmazonSimpleSystemsManagementEndpointResolver()); } ///

/// Capture metadata for the service. ///

protected override IServiceMetadata ServiceMetadata { get { return serviceMetadata; } } #endregion #region Dispose ///

/// Disposes the service client. ///

protected override void Dispose(bool disposing) { base.Dispose(disposing); } #endregion #region AddTagsToResource internal virtual AddTagsToResourceResponse AddTagsToResource(AddTagsToResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddTagsToResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddTagsToResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the AddTagsToResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AddTagsToResource service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The resource ID isn't valid. Verify that you entered the correct ID and try again. /// /// /// The resource type isn't valid. For example, if you are attempting to tag an EC2 instance, /// the instance must be a registered managed node. /// /// /// The Targets parameter includes too many tags. Remove one or more tags /// and try the command again. /// /// /// There are concurrent updates for a resource that supports one update at a time. /// /// REST API Reference for AddTagsToResource Operation public virtual Task AddTagsToResourceAsync(AddTagsToResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AddTagsToResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddTagsToResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AssociateOpsItemRelatedItem internal virtual AssociateOpsItemRelatedItemResponse AssociateOpsItemRelatedItem(AssociateOpsItemRelatedItemRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateOpsItemRelatedItemRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateOpsItemRelatedItemResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the AssociateOpsItemRelatedItem service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the AssociateOpsItemRelatedItem service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// A specified parameter argument isn't valid. Verify the available arguments and try /// again. /// /// /// The request caused OpsItems to exceed one or more quotas. /// /// /// The specified OpsItem ID doesn't exist. Verify the ID and try again. /// /// /// The Amazon Resource Name (ARN) is already associated with the OpsItem. /// /// REST API Reference for AssociateOpsItemRelatedItem Operation public virtual Task AssociateOpsItemRelatedItemAsync(AssociateOpsItemRelatedItemRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateOpsItemRelatedItemRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateOpsItemRelatedItemResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CancelCommand internal virtual CancelCommandResponse CancelCommand(CancelCommandRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelCommandRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelCommandResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// The ID of the command you want to cancel. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelCommand service method, as returned by SimpleSystemsManagement. /// /// You can't specify a managed node ID in more than one association. /// /// /// An error occurred on the server side. /// /// /// The specified command ID isn't valid. Verify the ID and try again. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// REST API Reference for CancelCommand Operation public virtual Task CancelCommandAsync(string commandId, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new CancelCommandRequest(); request.CommandId = commandId; return CancelCommandAsync(request, cancellationToken); } ///

/// 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. ///

/// The ID of the command you want to cancel. /// (Optional) A list of managed node IDs on which you want to cancel the command. If not provided, the command is canceled on every node on which it was requested. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelCommand service method, as returned by SimpleSystemsManagement. /// /// You can't specify a managed node ID in more than one association. /// /// /// An error occurred on the server side. /// /// /// The specified command ID isn't valid. Verify the ID and try again. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// REST API Reference for CancelCommand Operation public virtual Task CancelCommandAsync(string commandId, List instanceIds, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new CancelCommandRequest(); request.CommandId = commandId; request.InstanceIds = instanceIds; return CancelCommandAsync(request, cancellationToken); } ///

/// 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. ///

/// Container for the necessary parameters to execute the CancelCommand service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelCommand service method, as returned by SimpleSystemsManagement. /// /// You can't specify a managed node ID in more than one association. /// /// /// An error occurred on the server side. /// /// /// The specified command ID isn't valid. Verify the ID and try again. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// REST API Reference for CancelCommand Operation public virtual Task CancelCommandAsync(CancelCommandRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelCommandRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelCommandResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CancelMaintenanceWindowExecution internal virtual CancelMaintenanceWindowExecutionResponse CancelMaintenanceWindowExecution(CancelMaintenanceWindowExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelMaintenanceWindowExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelMaintenanceWindowExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the CancelMaintenanceWindowExecution service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CancelMaintenanceWindowExecution service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// REST API Reference for CancelMaintenanceWindowExecution Operation public virtual Task CancelMaintenanceWindowExecutionAsync(CancelMaintenanceWindowExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelMaintenanceWindowExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelMaintenanceWindowExecutionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateActivation internal virtual CreateActivationResponse CreateActivation(CreateActivationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateActivationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateActivationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the CreateActivation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateActivation service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// You must specify values for all required parameters in the Amazon Web Services Systems /// Manager document (SSM document). You can only supply values to parameters defined /// in the SSM document. /// /// REST API Reference for CreateActivation Operation public virtual Task CreateActivationAsync(CreateActivationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateActivationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateActivationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateAssociation internal virtual CreateAssociationResponse CreateAssociation(CreateAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// The managed node ID. InstanceId has been deprecated. To specify a managed node ID for an association, use the Targets parameter. Requests that include the parameter InstanceID with Systems Manager documents (SSM documents) that use schema version 2.0 or later will fail. In addition, if you use the parameter InstanceId, you can't use the parameters AssociationName, DocumentVersion, MaxErrors, MaxConcurrency, OutputLocation, or ScheduleExpression. To use these parameters, you must use the Targets parameter. /// The name of the SSM Command document or Automation runbook that contains the configuration information for the managed node. You can specify Amazon Web Services-predefined documents, documents you created, or a document that is shared with you from another Amazon Web Services account. For Systems Manager documents (SSM documents) that are shared with you from other Amazon Web Services accounts, you must specify the complete SSM document ARN, in the following format: arn:partition:ssm:region:account-id:document/document-name For example: arn:aws:ssm:us-east-2:12345678912:document/My-Shared-Document For Amazon Web Services-predefined documents and SSM documents you created in your account, you only need to specify the document name. For example, AWS-ApplyPatchBaseline or My-Document. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateAssociation service method, as returned by SimpleSystemsManagement. /// /// The specified association already exists. /// /// /// You can have at most 2,000 active associations. /// /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The document version isn't valid or doesn't exist. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The output location isn't valid or doesn't exist. /// /// /// You must specify values for all required parameters in the Amazon Web Services Systems /// Manager document (SSM document). You can only supply values to parameters defined /// in the SSM document. /// /// /// The schedule is invalid. Verify your cron or rate expression and try again. /// /// /// The specified tag key or value isn't valid. /// /// /// The target isn't valid or doesn't exist. It might not be configured for Systems Manager /// or you might not have permission to perform the operation. /// /// /// TargetMap parameter isn't valid. /// /// /// The document doesn't support the platform type of the given managed node ID(s). For /// example, you sent an document for a Windows managed node to a Linux node. /// /// REST API Reference for CreateAssociation Operation public virtual Task CreateAssociationAsync(string instanceId, string name, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new CreateAssociationRequest(); request.InstanceId = instanceId; request.Name = name; return CreateAssociationAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the CreateAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateAssociation service method, as returned by SimpleSystemsManagement. /// /// The specified association already exists. /// /// /// You can have at most 2,000 active associations. /// /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The document version isn't valid or doesn't exist. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The output location isn't valid or doesn't exist. /// /// /// You must specify values for all required parameters in the Amazon Web Services Systems /// Manager document (SSM document). You can only supply values to parameters defined /// in the SSM document. /// /// /// The schedule is invalid. Verify your cron or rate expression and try again. /// /// /// The specified tag key or value isn't valid. /// /// /// The target isn't valid or doesn't exist. It might not be configured for Systems Manager /// or you might not have permission to perform the operation. /// /// /// TargetMap parameter isn't valid. /// /// /// The document doesn't support the platform type of the given managed node ID(s). For /// example, you sent an document for a Windows managed node to a Linux node. /// /// REST API Reference for CreateAssociation Operation public virtual Task CreateAssociationAsync(CreateAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateAssociationBatch internal virtual CreateAssociationBatchResponse CreateAssociationBatch(CreateAssociationBatchRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAssociationBatchRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAssociationBatchResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateAssociationBatch service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateAssociationBatch service method, as returned by SimpleSystemsManagement. /// /// You can have at most 2,000 active associations. /// /// /// You can't specify a managed node ID in more than one association. /// /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The document version isn't valid or doesn't exist. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The output location isn't valid or doesn't exist. /// /// /// You must specify values for all required parameters in the Amazon Web Services Systems /// Manager document (SSM document). You can only supply values to parameters defined /// in the SSM document. /// /// /// The schedule is invalid. Verify your cron or rate expression and try again. /// /// /// The target isn't valid or doesn't exist. It might not be configured for Systems Manager /// or you might not have permission to perform the operation. /// /// /// TargetMap parameter isn't valid. /// /// /// The document doesn't support the platform type of the given managed node ID(s). For /// example, you sent an document for a Windows managed node to a Linux node. /// /// REST API Reference for CreateAssociationBatch Operation public virtual Task CreateAssociationBatchAsync(CreateAssociationBatchRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAssociationBatchRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAssociationBatchResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDocument internal virtual CreateDocumentResponse CreateDocument(CreateDocumentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDocumentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// The content for the new SSM document in JSON or YAML format. The content of the document must not exceed 64KB. This quota also includes the content specified for input parameters at runtime. We recommend storing the contents for your new document in an external JSON or YAML file and referencing the file in a command. For examples, see the following topics in the Amazon Web Services Systems Manager User Guide.

/// A name for the SSM document. You can't use the following strings as document name prefixes. These are reserved by Amazon Web Services for use as document name prefixes:

aws
amazon
amzn

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDocument service method, as returned by SimpleSystemsManagement. /// /// The specified document already exists. /// /// /// You can have at most 500 active SSM documents. /// /// /// An error occurred on the server side. /// /// /// The content for the document isn't valid. /// /// /// The version of the document schema isn't supported. /// /// /// The size limit of a document is 64 KB. /// /// REST API Reference for CreateDocument Operation public virtual Task CreateDocumentAsync(string content, string name, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new CreateDocumentRequest(); request.Content = content; request.Name = name; return CreateDocumentAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the CreateDocument service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateDocument service method, as returned by SimpleSystemsManagement. /// /// The specified document already exists. /// /// /// You can have at most 500 active SSM documents. /// /// /// An error occurred on the server side. /// /// /// The content for the document isn't valid. /// /// /// The version of the document schema isn't supported. /// /// /// The size limit of a document is 64 KB. /// /// REST API Reference for CreateDocument Operation public virtual Task CreateDocumentAsync(CreateDocumentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDocumentResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateMaintenanceWindow internal virtual CreateMaintenanceWindowResponse CreateMaintenanceWindow(CreateMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the CreateMaintenanceWindow service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateMaintenanceWindow service method, as returned by SimpleSystemsManagement. /// /// Error returned when an idempotent operation is retried and the parameters don't match /// the original call to the API with the same idempotency token. /// /// /// An error occurred on the server side. /// /// /// Error returned when the caller has exceeded the default resource quotas. For example, /// too many maintenance windows or patch baselines have been created. /// /// /// /// For information about resource quotas in Systems Manager, see Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// REST API Reference for CreateMaintenanceWindow Operation public virtual Task CreateMaintenanceWindowAsync(CreateMaintenanceWindowRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMaintenanceWindowResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateOpsItem internal virtual CreateOpsItemResponse CreateOpsItem(CreateOpsItemRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateOpsItemRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateOpsItemResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the CreateOpsItem service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateOpsItem service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// You don't have permission to view OpsItems in the specified account. Verify that your /// account is configured either as a Systems Manager delegated administrator or that /// you are logged into the Organizations management account. /// /// /// The OpsItem already exists. /// /// /// A specified parameter argument isn't valid. Verify the available arguments and try /// again. /// /// /// The request caused OpsItems to exceed one or more quotas. /// /// REST API Reference for CreateOpsItem Operation public virtual Task CreateOpsItemAsync(CreateOpsItemRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateOpsItemRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateOpsItemResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateOpsMetadata internal virtual CreateOpsMetadataResponse CreateOpsMetadata(CreateOpsMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateOpsMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the CreateOpsMetadata service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateOpsMetadata service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// An OpsMetadata object already exists for the selected resource. /// /// /// One of the arguments passed is invalid. /// /// /// Your account reached the maximum number of OpsMetadata objects allowed by Application /// Manager. The maximum is 200 OpsMetadata objects. Delete one or more OpsMetadata object /// and try again. /// /// /// The system is processing too many concurrent updates. Wait a few moments and try again. /// /// REST API Reference for CreateOpsMetadata Operation public virtual Task CreateOpsMetadataAsync(CreateOpsMetadataRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateOpsMetadataResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreatePatchBaseline internal virtual CreatePatchBaselineResponse CreatePatchBaseline(CreatePatchBaselineRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePatchBaselineResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Creates a patch baseline. /// /// /// /// For information about valid key-value pairs in PatchFilters for each /// supported operating system type, see PatchFilter. /// /// ///

/// Container for the necessary parameters to execute the CreatePatchBaseline service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreatePatchBaseline service method, as returned by SimpleSystemsManagement. /// /// Error returned when an idempotent operation is retried and the parameters don't match /// the original call to the API with the same idempotency token. /// /// /// An error occurred on the server side. /// /// /// Error returned when the caller has exceeded the default resource quotas. For example, /// too many maintenance windows or patch baselines have been created. /// /// /// /// For information about resource quotas in Systems Manager, see Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// REST API Reference for CreatePatchBaseline Operation public virtual Task CreatePatchBaselineAsync(CreatePatchBaselineRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePatchBaselineResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateResourceDataSync internal virtual CreateResourceDataSyncResponse CreateResourceDataSync(CreateResourceDataSyncRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateResourceDataSyncResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the CreateResourceDataSync service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateResourceDataSync service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// A sync configuration with the same name already exists. /// /// /// You have exceeded the allowed maximum sync configurations. /// /// /// The specified sync configuration is invalid. /// /// REST API Reference for CreateResourceDataSync Operation public virtual Task CreateResourceDataSyncAsync(CreateResourceDataSyncRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateResourceDataSyncResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteActivation internal virtual DeleteActivationResponse DeleteActivation(DeleteActivationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteActivationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteActivationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the DeleteActivation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteActivation service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The activation isn't valid. The activation might have been deleted, or the ActivationId /// and the ActivationCode don't match. /// /// /// The activation ID isn't valid. Verify the you entered the correct ActivationId or /// ActivationCode and try again. /// /// /// There are concurrent updates for a resource that supports one update at a time. /// /// REST API Reference for DeleteActivation Operation public virtual Task DeleteActivationAsync(DeleteActivationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteActivationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteActivationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteAssociation internal virtual DeleteAssociationResponse DeleteAssociation(DeleteAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// Container for the necessary parameters to execute the DeleteAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteAssociation service method, as returned by SimpleSystemsManagement. /// /// The specified association doesn't exist. /// /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// There are concurrent updates for a resource that supports one update at a time. /// /// REST API Reference for DeleteAssociation Operation public virtual Task DeleteAssociationAsync(DeleteAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDocument internal virtual DeleteDocumentResponse DeleteDocument(DeleteDocumentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDocumentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// The name of the document. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDocument service method, as returned by SimpleSystemsManagement. /// /// You must disassociate a document from all managed nodes before you can delete it. /// /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// You attempted to delete a document while it is still shared. You must stop sharing /// the document before you can delete it. /// /// REST API Reference for DeleteDocument Operation public virtual Task DeleteDocumentAsync(string name, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DeleteDocumentRequest(); request.Name = name; return DeleteDocumentAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the DeleteDocument service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteDocument service method, as returned by SimpleSystemsManagement. /// /// You must disassociate a document from all managed nodes before you can delete it. /// /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// You attempted to delete a document while it is still shared. You must stop sharing /// the document before you can delete it. /// /// REST API Reference for DeleteDocument Operation public virtual Task DeleteDocumentAsync(DeleteDocumentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDocumentResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteInventory internal virtual DeleteInventoryResponse DeleteInventory(DeleteInventoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteInventoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the DeleteInventory service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteInventory service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// One or more of the parameters specified for the delete operation isn't valid. Verify /// all parameters and try again. /// /// /// The request isn't valid. /// /// /// The delete inventory option specified isn't valid. Verify the option and try again. /// /// /// The parameter type name isn't valid. /// /// REST API Reference for DeleteInventory Operation public virtual Task DeleteInventoryAsync(DeleteInventoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteInventoryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteMaintenanceWindow internal virtual DeleteMaintenanceWindowResponse DeleteMaintenanceWindow(DeleteMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a maintenance window. ///

/// Container for the necessary parameters to execute the DeleteMaintenanceWindow service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteMaintenanceWindow service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for DeleteMaintenanceWindow Operation public virtual Task DeleteMaintenanceWindowAsync(DeleteMaintenanceWindowRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteMaintenanceWindowResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteOpsMetadata internal virtual DeleteOpsMetadataResponse DeleteOpsMetadata(DeleteOpsMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteOpsMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Delete OpsMetadata related to an application. ///

/// Container for the necessary parameters to execute the DeleteOpsMetadata service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteOpsMetadata service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// One of the arguments passed is invalid. /// /// /// The OpsMetadata object doesn't exist. /// /// REST API Reference for DeleteOpsMetadata Operation public virtual Task DeleteOpsMetadataAsync(DeleteOpsMetadataRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteOpsMetadataResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteParameter internal virtual DeleteParameterResponse DeleteParameter(DeleteParameterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteParameterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteParameterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DeleteParameter service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteParameter service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The parameter couldn't be found. Verify the name and try again. /// /// REST API Reference for DeleteParameter Operation public virtual Task DeleteParameterAsync(DeleteParameterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteParameterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteParameterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteParameters internal virtual DeleteParametersResponse DeleteParameters(DeleteParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DeleteParameters service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteParameters service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for DeleteParameters Operation public virtual Task DeleteParametersAsync(DeleteParametersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteParametersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeletePatchBaseline internal virtual DeletePatchBaselineResponse DeletePatchBaseline(DeletePatchBaselineRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePatchBaselineResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a patch baseline. ///

/// Container for the necessary parameters to execute the DeletePatchBaseline service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeletePatchBaseline service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// Error returned if an attempt is made to delete a patch baseline that is registered /// for a patch group. /// /// REST API Reference for DeletePatchBaseline Operation public virtual Task DeletePatchBaselineAsync(DeletePatchBaselineRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePatchBaselineResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteResourceDataSync internal virtual DeleteResourceDataSyncResponse DeleteResourceDataSync(DeleteResourceDataSyncRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourceDataSyncResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the DeleteResourceDataSync service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteResourceDataSync service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified sync configuration is invalid. /// /// /// The specified sync name wasn't found. /// /// REST API Reference for DeleteResourceDataSync Operation public virtual Task DeleteResourceDataSyncAsync(DeleteResourceDataSyncRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourceDataSyncResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteResourcePolicy internal virtual DeleteResourcePolicyResponse DeleteResourcePolicy(DeleteResourcePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourcePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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). ///

/// Container for the necessary parameters to execute the DeleteResourcePolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteResourcePolicy service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The hash provided in the call doesn't match the stored hash. This exception is thrown /// when trying to update an obsolete policy version or when multiple requests to update /// a policy are sent. /// /// /// One or more parameters specified for the call aren't valid. Verify the parameters /// and their values and try again. /// /// REST API Reference for DeleteResourcePolicy Operation public virtual Task DeleteResourcePolicyAsync(DeleteResourcePolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourcePolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeregisterManagedInstance internal virtual DeregisterManagedInstanceResponse DeregisterManagedInstance(DeregisterManagedInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterManagedInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterManagedInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the DeregisterManagedInstance service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeregisterManagedInstance service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// REST API Reference for DeregisterManagedInstance Operation public virtual Task DeregisterManagedInstanceAsync(DeregisterManagedInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterManagedInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterManagedInstanceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeregisterPatchBaselineForPatchGroup internal virtual DeregisterPatchBaselineForPatchGroupResponse DeregisterPatchBaselineForPatchGroup(DeregisterPatchBaselineForPatchGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterPatchBaselineForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterPatchBaselineForPatchGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Removes a patch group from a patch baseline. ///

/// Container for the necessary parameters to execute the DeregisterPatchBaselineForPatchGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeregisterPatchBaselineForPatchGroup service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The resource ID isn't valid. Verify that you entered the correct ID and try again. /// /// REST API Reference for DeregisterPatchBaselineForPatchGroup Operation public virtual Task DeregisterPatchBaselineForPatchGroupAsync(DeregisterPatchBaselineForPatchGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterPatchBaselineForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterPatchBaselineForPatchGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeregisterTargetFromMaintenanceWindow internal virtual DeregisterTargetFromMaintenanceWindowResponse DeregisterTargetFromMaintenanceWindow(DeregisterTargetFromMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterTargetFromMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterTargetFromMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Removes a target from a maintenance window. ///

/// Container for the necessary parameters to execute the DeregisterTargetFromMaintenanceWindow service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeregisterTargetFromMaintenanceWindow service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// /// You specified the Safe option for the DeregisterTargetFromMaintenanceWindow /// operation, but the target is still referenced in a task. /// /// REST API Reference for DeregisterTargetFromMaintenanceWindow Operation public virtual Task DeregisterTargetFromMaintenanceWindowAsync(DeregisterTargetFromMaintenanceWindowRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterTargetFromMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterTargetFromMaintenanceWindowResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeregisterTaskFromMaintenanceWindow internal virtual DeregisterTaskFromMaintenanceWindowResponse DeregisterTaskFromMaintenanceWindow(DeregisterTaskFromMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterTaskFromMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterTaskFromMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Removes a task from a maintenance window. ///

/// Container for the necessary parameters to execute the DeregisterTaskFromMaintenanceWindow service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeregisterTaskFromMaintenanceWindow service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// REST API Reference for DeregisterTaskFromMaintenanceWindow Operation public virtual Task DeregisterTaskFromMaintenanceWindowAsync(DeregisterTaskFromMaintenanceWindowRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterTaskFromMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterTaskFromMaintenanceWindowResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeActivations internal virtual DescribeActivationsResponse DescribeActivations(DescribeActivationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeActivationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeActivationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the DescribeActivations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeActivations service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The filter name isn't valid. Verify the you entered the correct name and try again. /// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeActivations Operation public virtual Task DescribeActivationsAsync(DescribeActivationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeActivationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeActivationsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAssociation internal virtual DescribeAssociationResponse DescribeAssociation(DescribeAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// The managed node ID. /// The name of the SSM document. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAssociation service method, as returned by SimpleSystemsManagement. /// /// The specified association doesn't exist. /// /// /// An error occurred on the server side. /// /// /// The version you specified isn't valid. Use ListAssociationVersions to view all versions /// of an association according to the association ID. Or, use the $LATEST /// parameter to view the latest version of the association. /// /// /// The specified SSM document doesn't exist. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// REST API Reference for DescribeAssociation Operation public virtual Task DescribeAssociationAsync(string instanceId, string name, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DescribeAssociationRequest(); request.InstanceId = instanceId; request.Name = name; return DescribeAssociationAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAssociation service method, as returned by SimpleSystemsManagement. /// /// The specified association doesn't exist. /// /// /// An error occurred on the server side. /// /// /// The version you specified isn't valid. Use ListAssociationVersions to view all versions /// of an association according to the association ID. Or, use the $LATEST /// parameter to view the latest version of the association. /// /// /// The specified SSM document doesn't exist. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// REST API Reference for DescribeAssociation Operation public virtual Task DescribeAssociationAsync(DescribeAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAssociationExecutions internal virtual DescribeAssociationExecutionsResponse DescribeAssociationExecutions(DescribeAssociationExecutionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAssociationExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAssociationExecutionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Views all executions for a specific association ID. ///

/// Container for the necessary parameters to execute the DescribeAssociationExecutions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAssociationExecutions service method, as returned by SimpleSystemsManagement. /// /// The specified association doesn't exist. /// /// /// An error occurred on the server side. /// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeAssociationExecutions Operation public virtual Task DescribeAssociationExecutionsAsync(DescribeAssociationExecutionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAssociationExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAssociationExecutionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAssociationExecutionTargets internal virtual DescribeAssociationExecutionTargetsResponse DescribeAssociationExecutionTargets(DescribeAssociationExecutionTargetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAssociationExecutionTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAssociationExecutionTargetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeAssociationExecutionTargets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAssociationExecutionTargets service method, as returned by SimpleSystemsManagement. /// /// The specified association doesn't exist. /// /// /// The specified execution ID doesn't exist. Verify the ID number and try again. /// /// /// An error occurred on the server side. /// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeAssociationExecutionTargets Operation public virtual Task DescribeAssociationExecutionTargetsAsync(DescribeAssociationExecutionTargetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAssociationExecutionTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAssociationExecutionTargetsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAutomationExecutions internal virtual DescribeAutomationExecutionsResponse DescribeAutomationExecutions(DescribeAutomationExecutionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAutomationExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAutomationExecutionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Provides details about all active and terminated Automation executions. ///

/// Container for the necessary parameters to execute the DescribeAutomationExecutions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAutomationExecutions service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified key isn't valid. /// /// /// The filter value isn't valid. Verify the value and try again. /// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeAutomationExecutions Operation public virtual Task DescribeAutomationExecutionsAsync(DescribeAutomationExecutionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAutomationExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAutomationExecutionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAutomationStepExecutions internal virtual DescribeAutomationStepExecutionsResponse DescribeAutomationStepExecutions(DescribeAutomationStepExecutionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAutomationStepExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAutomationStepExecutionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeAutomationStepExecutions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAutomationStepExecutions service method, as returned by SimpleSystemsManagement. /// /// There is no automation execution information for the requested automation execution /// ID. /// /// /// An error occurred on the server side. /// /// /// The specified key isn't valid. /// /// /// The filter value isn't valid. Verify the value and try again. /// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeAutomationStepExecutions Operation public virtual Task DescribeAutomationStepExecutionsAsync(DescribeAutomationStepExecutionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAutomationStepExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAutomationStepExecutionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeAvailablePatches internal virtual DescribeAvailablePatchesResponse DescribeAvailablePatches(DescribeAvailablePatchesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAvailablePatchesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAvailablePatchesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeAvailablePatches service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeAvailablePatches service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for DescribeAvailablePatches Operation public virtual Task DescribeAvailablePatchesAsync(DescribeAvailablePatchesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAvailablePatchesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAvailablePatchesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDocument internal virtual DescribeDocumentResponse DescribeDocument(DescribeDocumentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDocumentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// The name of the SSM document. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDocument service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The document version isn't valid or doesn't exist. /// /// REST API Reference for DescribeDocument Operation public virtual Task DescribeDocumentAsync(string name, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new DescribeDocumentRequest(); request.Name = name; return DescribeDocumentAsync(request, cancellationToken); } ///

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

/// Container for the necessary parameters to execute the DescribeDocument service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDocument service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The document version isn't valid or doesn't exist. /// /// REST API Reference for DescribeDocument Operation public virtual Task DescribeDocumentAsync(DescribeDocumentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDocumentResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDocumentPermission internal virtual DescribeDocumentPermissionResponse DescribeDocumentPermission(DescribeDocumentPermissionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDocumentPermissionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDocumentPermissionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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). ///

/// Container for the necessary parameters to execute the DescribeDocumentPermission service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeDocumentPermission service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// You attempted to delete a document while it is still shared. You must stop sharing /// the document before you can delete it. /// /// /// The specified token isn't valid. /// /// /// The permission type isn't supported. Share is the only supported permission /// type. /// /// REST API Reference for DescribeDocumentPermission Operation public virtual Task DescribeDocumentPermissionAsync(DescribeDocumentPermissionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDocumentPermissionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDocumentPermissionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEffectiveInstanceAssociations internal virtual DescribeEffectiveInstanceAssociationsResponse DescribeEffectiveInstanceAssociations(DescribeEffectiveInstanceAssociationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEffectiveInstanceAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEffectiveInstanceAssociationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// All associations for the managed node(s). ///

/// Container for the necessary parameters to execute the DescribeEffectiveInstanceAssociations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEffectiveInstanceAssociations service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeEffectiveInstanceAssociations Operation public virtual Task DescribeEffectiveInstanceAssociationsAsync(DescribeEffectiveInstanceAssociationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEffectiveInstanceAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEffectiveInstanceAssociationsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEffectivePatchesForPatchBaseline internal virtual DescribeEffectivePatchesForPatchBaselineResponse DescribeEffectivePatchesForPatchBaseline(DescribeEffectivePatchesForPatchBaselineRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEffectivePatchesForPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEffectivePatchesForPatchBaselineResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeEffectivePatchesForPatchBaseline service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeEffectivePatchesForPatchBaseline service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// /// The resource ID isn't valid. Verify that you entered the correct ID and try again. /// /// /// The operating systems you specified isn't supported, or the operation isn't supported /// for the operating system. /// /// REST API Reference for DescribeEffectivePatchesForPatchBaseline Operation public virtual Task DescribeEffectivePatchesForPatchBaselineAsync(DescribeEffectivePatchesForPatchBaselineRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEffectivePatchesForPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEffectivePatchesForPatchBaselineResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeInstanceAssociationsStatus internal virtual DescribeInstanceAssociationsStatusResponse DescribeInstanceAssociationsStatus(DescribeInstanceAssociationsStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstanceAssociationsStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstanceAssociationsStatusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeInstanceAssociationsStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstanceAssociationsStatus service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeInstanceAssociationsStatus Operation public virtual Task DescribeInstanceAssociationsStatusAsync(DescribeInstanceAssociationsStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstanceAssociationsStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstanceAssociationsStatusResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeInstanceInformation internal virtual DescribeInstanceInformationResponse DescribeInstanceInformation() { return DescribeInstanceInformation(new DescribeInstanceInformationRequest()); } internal virtual DescribeInstanceInformationResponse DescribeInstanceInformation(DescribeInstanceInformationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstanceInformationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstanceInformationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstanceInformation service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified key isn't valid. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The specified filter value isn't valid. /// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeInstanceInformation Operation public virtual Task DescribeInstanceInformationAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeInstanceInformationAsync(new DescribeInstanceInformationRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeInstanceInformation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstanceInformation service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified key isn't valid. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The specified filter value isn't valid. /// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeInstanceInformation Operation public virtual Task DescribeInstanceInformationAsync(DescribeInstanceInformationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstanceInformationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstanceInformationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeInstancePatches internal virtual DescribeInstancePatchesResponse DescribeInstancePatches(DescribeInstancePatchesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstancePatchesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstancePatchesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeInstancePatches service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstancePatches service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The filter name isn't valid. Verify the you entered the correct name and try again. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeInstancePatches Operation public virtual Task DescribeInstancePatchesAsync(DescribeInstancePatchesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstancePatchesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstancePatchesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeInstancePatchStates internal virtual DescribeInstancePatchStatesResponse DescribeInstancePatchStates(DescribeInstancePatchStatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstancePatchStatesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstancePatchStatesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeInstancePatchStates service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstancePatchStates service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeInstancePatchStates Operation public virtual Task DescribeInstancePatchStatesAsync(DescribeInstancePatchStatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstancePatchStatesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstancePatchStatesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeInstancePatchStatesForPatchGroup internal virtual DescribeInstancePatchStatesForPatchGroupResponse DescribeInstancePatchStatesForPatchGroup(DescribeInstancePatchStatesForPatchGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstancePatchStatesForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstancePatchStatesForPatchGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeInstancePatchStatesForPatchGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInstancePatchStatesForPatchGroup service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The filter name isn't valid. Verify the you entered the correct name and try again. /// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeInstancePatchStatesForPatchGroup Operation public virtual Task DescribeInstancePatchStatesForPatchGroupAsync(DescribeInstancePatchStatesForPatchGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstancePatchStatesForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstancePatchStatesForPatchGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeInventoryDeletions internal virtual DescribeInventoryDeletionsResponse DescribeInventoryDeletions(DescribeInventoryDeletionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInventoryDeletionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInventoryDeletionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Describes a specific delete inventory operation. ///

/// Container for the necessary parameters to execute the DescribeInventoryDeletions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeInventoryDeletions service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The ID specified for the delete operation doesn't exist or isn't valid. Verify the /// ID and try again. /// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeInventoryDeletions Operation public virtual Task DescribeInventoryDeletionsAsync(DescribeInventoryDeletionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInventoryDeletionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInventoryDeletionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeMaintenanceWindowExecutions internal virtual DescribeMaintenanceWindowExecutionsResponse DescribeMaintenanceWindowExecutions(DescribeMaintenanceWindowExecutionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowExecutionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the DescribeMaintenanceWindowExecutions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeMaintenanceWindowExecutions service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for DescribeMaintenanceWindowExecutions Operation public virtual Task DescribeMaintenanceWindowExecutionsAsync(DescribeMaintenanceWindowExecutionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowExecutionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeMaintenanceWindowExecutionTaskInvocations internal virtual DescribeMaintenanceWindowExecutionTaskInvocationsResponse DescribeMaintenanceWindowExecutionTaskInvocations(DescribeMaintenanceWindowExecutionTaskInvocationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowExecutionTaskInvocationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowExecutionTaskInvocationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeMaintenanceWindowExecutionTaskInvocations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeMaintenanceWindowExecutionTaskInvocations service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// REST API Reference for DescribeMaintenanceWindowExecutionTaskInvocations Operation public virtual Task DescribeMaintenanceWindowExecutionTaskInvocationsAsync(DescribeMaintenanceWindowExecutionTaskInvocationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowExecutionTaskInvocationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowExecutionTaskInvocationsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeMaintenanceWindowExecutionTasks internal virtual DescribeMaintenanceWindowExecutionTasksResponse DescribeMaintenanceWindowExecutionTasks(DescribeMaintenanceWindowExecutionTasksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowExecutionTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowExecutionTasksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeMaintenanceWindowExecutionTasks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeMaintenanceWindowExecutionTasks service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// REST API Reference for DescribeMaintenanceWindowExecutionTasks Operation public virtual Task DescribeMaintenanceWindowExecutionTasksAsync(DescribeMaintenanceWindowExecutionTasksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowExecutionTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowExecutionTasksResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeMaintenanceWindows internal virtual DescribeMaintenanceWindowsResponse DescribeMaintenanceWindows(DescribeMaintenanceWindowsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeMaintenanceWindows service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeMaintenanceWindows service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for DescribeMaintenanceWindows Operation public virtual Task DescribeMaintenanceWindowsAsync(DescribeMaintenanceWindowsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeMaintenanceWindowSchedule internal virtual DescribeMaintenanceWindowScheduleResponse DescribeMaintenanceWindowSchedule(DescribeMaintenanceWindowScheduleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowScheduleRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowScheduleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Retrieves information about upcoming executions of a maintenance window. ///

/// Container for the necessary parameters to execute the DescribeMaintenanceWindowSchedule service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeMaintenanceWindowSchedule service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// REST API Reference for DescribeMaintenanceWindowSchedule Operation public virtual Task DescribeMaintenanceWindowScheduleAsync(DescribeMaintenanceWindowScheduleRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowScheduleRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowScheduleResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeMaintenanceWindowsForTarget internal virtual DescribeMaintenanceWindowsForTargetResponse DescribeMaintenanceWindowsForTarget(DescribeMaintenanceWindowsForTargetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowsForTargetRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowsForTargetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeMaintenanceWindowsForTarget service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeMaintenanceWindowsForTarget service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for DescribeMaintenanceWindowsForTarget Operation public virtual Task DescribeMaintenanceWindowsForTargetAsync(DescribeMaintenanceWindowsForTargetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowsForTargetRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowsForTargetResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeMaintenanceWindowTargets internal virtual DescribeMaintenanceWindowTargetsResponse DescribeMaintenanceWindowTargets(DescribeMaintenanceWindowTargetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowTargetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Lists the targets registered with the maintenance window. ///

/// Container for the necessary parameters to execute the DescribeMaintenanceWindowTargets service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeMaintenanceWindowTargets service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// REST API Reference for DescribeMaintenanceWindowTargets Operation public virtual Task DescribeMaintenanceWindowTargetsAsync(DescribeMaintenanceWindowTargetsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowTargetsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeMaintenanceWindowTasks internal virtual DescribeMaintenanceWindowTasksResponse DescribeMaintenanceWindowTasks(DescribeMaintenanceWindowTasksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowTasksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the DescribeMaintenanceWindowTasks service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeMaintenanceWindowTasks service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// REST API Reference for DescribeMaintenanceWindowTasks Operation public virtual Task DescribeMaintenanceWindowTasksAsync(DescribeMaintenanceWindowTasksRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowTasksResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeOpsItems internal virtual DescribeOpsItemsResponse DescribeOpsItems(DescribeOpsItemsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeOpsItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeOpsItemsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the DescribeOpsItems service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeOpsItems service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for DescribeOpsItems Operation public virtual Task DescribeOpsItemsAsync(DescribeOpsItemsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeOpsItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeOpsItemsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeParameters internal virtual DescribeParametersResponse DescribeParameters(DescribeParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the DescribeParameters service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeParameters service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified key isn't valid. /// /// /// The specified filter option isn't valid. Valid options are Equals and BeginsWith. /// For Path filter, valid options are Recursive and OneLevel. /// /// /// The filter value isn't valid. Verify the value and try again. /// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeParameters Operation public virtual Task DescribeParametersAsync(DescribeParametersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeParametersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribePatchBaselines internal virtual DescribePatchBaselinesResponse DescribePatchBaselines(DescribePatchBaselinesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchBaselinesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchBaselinesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Lists the patch baselines in your Amazon Web Services account. ///

/// Container for the necessary parameters to execute the DescribePatchBaselines service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribePatchBaselines service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for DescribePatchBaselines Operation public virtual Task DescribePatchBaselinesAsync(DescribePatchBaselinesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchBaselinesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchBaselinesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribePatchGroups internal virtual DescribePatchGroupsResponse DescribePatchGroups(DescribePatchGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribePatchGroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribePatchGroups service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for DescribePatchGroups Operation public virtual Task DescribePatchGroupsAsync(DescribePatchGroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchGroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribePatchGroupState internal virtual DescribePatchGroupStateResponse DescribePatchGroupState(DescribePatchGroupStateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchGroupStateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchGroupStateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribePatchGroupState service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribePatchGroupState service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified token isn't valid. /// /// REST API Reference for DescribePatchGroupState Operation public virtual Task DescribePatchGroupStateAsync(DescribePatchGroupStateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchGroupStateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchGroupStateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribePatchProperties internal virtual DescribePatchPropertiesResponse DescribePatchProperties(DescribePatchPropertiesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchPropertiesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchPropertiesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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 /// ///

///

/// Container for the necessary parameters to execute the DescribePatchProperties service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribePatchProperties service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for DescribePatchProperties Operation public virtual Task DescribePatchPropertiesAsync(DescribePatchPropertiesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchPropertiesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchPropertiesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeSessions internal virtual DescribeSessionsResponse DescribeSessions(DescribeSessionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSessionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSessionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeSessions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DescribeSessions service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified key isn't valid. /// /// /// The specified token isn't valid. /// /// REST API Reference for DescribeSessions Operation public virtual Task DescribeSessionsAsync(DescribeSessionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSessionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSessionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DisassociateOpsItemRelatedItem internal virtual DisassociateOpsItemRelatedItemResponse DisassociateOpsItemRelatedItem(DisassociateOpsItemRelatedItemRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateOpsItemRelatedItemRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateOpsItemRelatedItemResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the DisassociateOpsItemRelatedItem service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DisassociateOpsItemRelatedItem service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// A specified parameter argument isn't valid. Verify the available arguments and try /// again. /// /// /// The specified OpsItem ID doesn't exist. Verify the ID and try again. /// /// /// The association wasn't found using the parameters you specified in the call. Verify /// the information and try again. /// /// REST API Reference for DisassociateOpsItemRelatedItem Operation public virtual Task DisassociateOpsItemRelatedItemAsync(DisassociateOpsItemRelatedItemRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateOpsItemRelatedItemRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateOpsItemRelatedItemResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetAutomationExecution internal virtual GetAutomationExecutionResponse GetAutomationExecution(GetAutomationExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetAutomationExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAutomationExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Get detailed information about a particular Automation execution. ///

/// Container for the necessary parameters to execute the GetAutomationExecution service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetAutomationExecution service method, as returned by SimpleSystemsManagement. /// /// There is no automation execution information for the requested automation execution /// ID. /// /// /// An error occurred on the server side. /// /// REST API Reference for GetAutomationExecution Operation public virtual Task GetAutomationExecutionAsync(GetAutomationExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetAutomationExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAutomationExecutionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetCalendarState internal virtual GetCalendarStateResponse GetCalendarState(GetCalendarStateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCalendarStateRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCalendarStateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetCalendarState service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetCalendarState service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The SSM document type isn't valid. Valid document types are described in the DocumentType /// property. /// /// /// The calendar entry contained in the specified SSM document isn't supported. /// /// REST API Reference for GetCalendarState Operation public virtual Task GetCalendarStateAsync(GetCalendarStateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetCalendarStateRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCalendarStateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetCommandInvocation internal virtual GetCommandInvocationResponse GetCommandInvocation(GetCommandInvocationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCommandInvocationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCommandInvocationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetCommandInvocation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetCommandInvocation service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified command ID isn't valid. Verify the ID and try again. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The plugin name isn't valid. /// /// /// The command ID and managed node ID you specified didn't match any invocations. Verify /// the command ID and the managed node ID and try again. /// /// REST API Reference for GetCommandInvocation Operation public virtual Task GetCommandInvocationAsync(GetCommandInvocationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetCommandInvocationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCommandInvocationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetConnectionStatus internal virtual GetConnectionStatusResponse GetConnectionStatus(GetConnectionStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetConnectionStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConnectionStatusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the GetConnectionStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetConnectionStatus service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for GetConnectionStatus Operation public virtual Task GetConnectionStatusAsync(GetConnectionStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetConnectionStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConnectionStatusResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetDefaultPatchBaseline internal virtual GetDefaultPatchBaselineResponse GetDefaultPatchBaseline(GetDefaultPatchBaselineRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDefaultPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDefaultPatchBaselineResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetDefaultPatchBaseline service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetDefaultPatchBaseline service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for GetDefaultPatchBaseline Operation public virtual Task GetDefaultPatchBaselineAsync(GetDefaultPatchBaselineRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetDefaultPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDefaultPatchBaselineResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetDeployablePatchSnapshotForInstance internal virtual GetDeployablePatchSnapshotForInstanceResponse GetDeployablePatchSnapshotForInstance(GetDeployablePatchSnapshotForInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDeployablePatchSnapshotForInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDeployablePatchSnapshotForInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the GetDeployablePatchSnapshotForInstance service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetDeployablePatchSnapshotForInstance service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// Patching for applications released by Microsoft is only available on EC2 instances /// and advanced instances. To patch applications released by Microsoft on on-premises /// servers and VMs, you must enable advanced instances. For more information, see Enabling /// the advanced-instances tier in the Amazon Web Services Systems Manager User /// Guide. /// /// /// The operating systems you specified isn't supported, or the operation isn't supported /// for the operating system. /// /// REST API Reference for GetDeployablePatchSnapshotForInstance Operation public virtual Task GetDeployablePatchSnapshotForInstanceAsync(GetDeployablePatchSnapshotForInstanceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetDeployablePatchSnapshotForInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDeployablePatchSnapshotForInstanceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetDocument internal virtual GetDocumentResponse GetDocument(GetDocumentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDocumentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// The name of the SSM document. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetDocument service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The document version isn't valid or doesn't exist. /// /// REST API Reference for GetDocument Operation public virtual Task GetDocumentAsync(string name, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new GetDocumentRequest(); request.Name = name; return GetDocumentAsync(request, cancellationToken); } ///

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

/// Container for the necessary parameters to execute the GetDocument service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetDocument service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The document version isn't valid or doesn't exist. /// /// REST API Reference for GetDocument Operation public virtual Task GetDocumentAsync(GetDocumentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDocumentResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetInventory internal virtual GetInventoryResponse GetInventory(GetInventoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInventoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the GetInventory service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetInventory service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified aggregator isn't valid for inventory groups. Verify that the aggregator /// uses a valid inventory type such as AWS:Application or AWS:InstanceInformation. /// /// /// The filter name isn't valid. Verify the you entered the correct name and try again. /// /// /// The specified inventory group isn't valid. /// /// /// The specified token isn't valid. /// /// /// The specified inventory item result attribute isn't valid. /// /// /// The parameter type name isn't valid. /// /// REST API Reference for GetInventory Operation public virtual Task GetInventoryAsync(GetInventoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInventoryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetInventorySchema internal virtual GetInventorySchemaResponse GetInventorySchema(GetInventorySchemaRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetInventorySchemaRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInventorySchemaResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the GetInventorySchema service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetInventorySchema service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified token isn't valid. /// /// /// The parameter type name isn't valid. /// /// REST API Reference for GetInventorySchema Operation public virtual Task GetInventorySchemaAsync(GetInventorySchemaRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetInventorySchemaRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInventorySchemaResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetMaintenanceWindow internal virtual GetMaintenanceWindowResponse GetMaintenanceWindow(GetMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Retrieves a maintenance window. ///

/// Container for the necessary parameters to execute the GetMaintenanceWindow service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetMaintenanceWindow service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// REST API Reference for GetMaintenanceWindow Operation public virtual Task GetMaintenanceWindowAsync(GetMaintenanceWindowRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetMaintenanceWindowExecution internal virtual GetMaintenanceWindowExecutionResponse GetMaintenanceWindowExecution(GetMaintenanceWindowExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Retrieves details about a specific a maintenance window execution. ///

/// Container for the necessary parameters to execute the GetMaintenanceWindowExecution service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetMaintenanceWindowExecution service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// REST API Reference for GetMaintenanceWindowExecution Operation public virtual Task GetMaintenanceWindowExecutionAsync(GetMaintenanceWindowExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowExecutionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetMaintenanceWindowExecutionTask internal virtual GetMaintenanceWindowExecutionTaskResponse GetMaintenanceWindowExecutionTask(GetMaintenanceWindowExecutionTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowExecutionTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowExecutionTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the GetMaintenanceWindowExecutionTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetMaintenanceWindowExecutionTask service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// REST API Reference for GetMaintenanceWindowExecutionTask Operation public virtual Task GetMaintenanceWindowExecutionTaskAsync(GetMaintenanceWindowExecutionTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowExecutionTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowExecutionTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetMaintenanceWindowExecutionTaskInvocation internal virtual GetMaintenanceWindowExecutionTaskInvocationResponse GetMaintenanceWindowExecutionTaskInvocation(GetMaintenanceWindowExecutionTaskInvocationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowExecutionTaskInvocationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowExecutionTaskInvocationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the GetMaintenanceWindowExecutionTaskInvocation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetMaintenanceWindowExecutionTaskInvocation service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// REST API Reference for GetMaintenanceWindowExecutionTaskInvocation Operation public virtual Task GetMaintenanceWindowExecutionTaskInvocationAsync(GetMaintenanceWindowExecutionTaskInvocationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowExecutionTaskInvocationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowExecutionTaskInvocationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetMaintenanceWindowTask internal virtual GetMaintenanceWindowTaskResponse GetMaintenanceWindowTask(GetMaintenanceWindowTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetMaintenanceWindowTask service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetMaintenanceWindowTask service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// REST API Reference for GetMaintenanceWindowTask Operation public virtual Task GetMaintenanceWindowTaskAsync(GetMaintenanceWindowTaskRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowTaskResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetOpsItem internal virtual GetOpsItemResponse GetOpsItem(GetOpsItemRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetOpsItemRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOpsItemResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetOpsItem service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetOpsItem service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// You don't have permission to view OpsItems in the specified account. Verify that your /// account is configured either as a Systems Manager delegated administrator or that /// you are logged into the Organizations management account. /// /// /// The specified OpsItem ID doesn't exist. Verify the ID and try again. /// /// REST API Reference for GetOpsItem Operation public virtual Task GetOpsItemAsync(GetOpsItemRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetOpsItemRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOpsItemResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetOpsMetadata internal virtual GetOpsMetadataResponse GetOpsMetadata(GetOpsMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOpsMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the GetOpsMetadata service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetOpsMetadata service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// One of the arguments passed is invalid. /// /// /// The OpsMetadata object doesn't exist. /// /// REST API Reference for GetOpsMetadata Operation public virtual Task GetOpsMetadataAsync(GetOpsMetadataRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOpsMetadataResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetOpsSummary internal virtual GetOpsSummaryResponse GetOpsSummary(GetOpsSummaryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetOpsSummaryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOpsSummaryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the GetOpsSummary service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetOpsSummary service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified aggregator isn't valid for inventory groups. Verify that the aggregator /// uses a valid inventory type such as AWS:Application or AWS:InstanceInformation. /// /// /// The filter name isn't valid. Verify the you entered the correct name and try again. /// /// /// The specified token isn't valid. /// /// /// The parameter type name isn't valid. /// /// /// The specified sync name wasn't found. /// /// REST API Reference for GetOpsSummary Operation public virtual Task GetOpsSummaryAsync(GetOpsSummaryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetOpsSummaryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOpsSummaryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetParameter internal virtual GetParameterResponse GetParameter(GetParameterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetParameterRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParameterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the GetParameter service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetParameter service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The query key ID isn't valid. /// /// /// The parameter couldn't be found. Verify the name and try again. /// /// /// The specified parameter version wasn't found. Verify the parameter name and version, /// and try again. /// /// REST API Reference for GetParameter Operation public virtual Task GetParameterAsync(GetParameterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetParameterRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParameterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetParameterHistory internal virtual GetParameterHistoryResponse GetParameterHistory(GetParameterHistoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetParameterHistoryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParameterHistoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the GetParameterHistory service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetParameterHistory service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The query key ID isn't valid. /// /// /// The specified token isn't valid. /// /// /// The parameter couldn't be found. Verify the name and try again. /// /// REST API Reference for GetParameterHistory Operation public virtual Task GetParameterHistoryAsync(GetParameterHistoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetParameterHistoryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParameterHistoryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetParameters internal virtual GetParametersResponse GetParameters(GetParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the GetParameters service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetParameters service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The query key ID isn't valid. /// /// REST API Reference for GetParameters Operation public virtual Task GetParametersAsync(GetParametersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParametersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetParametersByPath internal virtual GetParametersByPathResponse GetParametersByPath(GetParametersByPathRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetParametersByPathRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParametersByPathResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetParametersByPath service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetParametersByPath service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified key isn't valid. /// /// /// The specified filter option isn't valid. Valid options are Equals and BeginsWith. /// For Path filter, valid options are Recursive and OneLevel. /// /// /// The filter value isn't valid. Verify the value and try again. /// /// /// The query key ID isn't valid. /// /// /// The specified token isn't valid. /// /// REST API Reference for GetParametersByPath Operation public virtual Task GetParametersByPathAsync(GetParametersByPathRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetParametersByPathRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParametersByPathResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetPatchBaseline internal virtual GetPatchBaselineResponse GetPatchBaseline(GetPatchBaselineRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = GetPatchBaselineResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Retrieves information about a patch baseline. ///

/// Container for the necessary parameters to execute the GetPatchBaseline service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetPatchBaseline service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// /// The resource ID isn't valid. Verify that you entered the correct ID and try again. /// /// REST API Reference for GetPatchBaseline Operation public virtual Task GetPatchBaselineAsync(GetPatchBaselineRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = GetPatchBaselineResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetPatchBaselineForPatchGroup internal virtual GetPatchBaselineForPatchGroupResponse GetPatchBaselineForPatchGroup(GetPatchBaselineForPatchGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetPatchBaselineForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = GetPatchBaselineForPatchGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the GetPatchBaselineForPatchGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetPatchBaselineForPatchGroup service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for GetPatchBaselineForPatchGroup Operation public virtual Task GetPatchBaselineForPatchGroupAsync(GetPatchBaselineForPatchGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetPatchBaselineForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = GetPatchBaselineForPatchGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetResourcePolicies internal virtual GetResourcePoliciesResponse GetResourcePolicies(GetResourcePoliciesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetResourcePoliciesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetResourcePoliciesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns an array of the Policy object. ///

/// Container for the necessary parameters to execute the GetResourcePolicies service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetResourcePolicies service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// One or more parameters specified for the call aren't valid. Verify the parameters /// and their values and try again. /// /// REST API Reference for GetResourcePolicies Operation public virtual Task GetResourcePoliciesAsync(GetResourcePoliciesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetResourcePoliciesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetResourcePoliciesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetServiceSetting internal virtual GetServiceSettingResponse GetServiceSetting(GetServiceSettingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceSettingRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceSettingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the GetServiceSetting service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the GetServiceSetting service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified service setting wasn't found. Either the service name or the setting /// hasn't been provisioned by the Amazon Web Services service team. /// /// REST API Reference for GetServiceSetting Operation public virtual Task GetServiceSettingAsync(GetServiceSettingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceSettingRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceSettingResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region LabelParameterVersion internal virtual LabelParameterVersionResponse LabelParameterVersion(LabelParameterVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = LabelParameterVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = LabelParameterVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

///

/// Container for the necessary parameters to execute the LabelParameterVersion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the LabelParameterVersion service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The parameter couldn't be found. Verify the name and try again. /// /// /// A parameter version can have a maximum of ten labels. /// /// /// The specified parameter version wasn't found. Verify the parameter name and version, /// and try again. /// /// /// There are concurrent updates for a resource that supports one update at a time. /// /// REST API Reference for LabelParameterVersion Operation public virtual Task LabelParameterVersionAsync(LabelParameterVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = LabelParameterVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = LabelParameterVersionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListAssociations internal virtual ListAssociationsResponse ListAssociations(ListAssociationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAssociationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the ListAssociations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListAssociations service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified token isn't valid. /// /// REST API Reference for ListAssociations Operation public virtual Task ListAssociationsAsync(ListAssociationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAssociationsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListAssociationVersions internal virtual ListAssociationVersionsResponse ListAssociationVersions(ListAssociationVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListAssociationVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAssociationVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ListAssociationVersions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListAssociationVersions service method, as returned by SimpleSystemsManagement. /// /// The specified association doesn't exist. /// /// /// An error occurred on the server side. /// /// /// The specified token isn't valid. /// /// REST API Reference for ListAssociationVersions Operation public virtual Task ListAssociationVersionsAsync(ListAssociationVersionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListAssociationVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAssociationVersionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListCommandInvocations internal virtual ListCommandInvocationsResponse ListCommandInvocations() { return ListCommandInvocations(new ListCommandInvocationsRequest()); } internal virtual ListCommandInvocationsResponse ListCommandInvocations(ListCommandInvocationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListCommandInvocationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCommandInvocationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListCommandInvocations service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified command ID isn't valid. Verify the ID and try again. /// /// /// The specified key isn't valid. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The specified token isn't valid. /// /// REST API Reference for ListCommandInvocations Operation public virtual Task ListCommandInvocationsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return ListCommandInvocationsAsync(new ListCommandInvocationsRequest(), cancellationToken); } ///

/// (Optional) The invocations for a specific command ID. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListCommandInvocations service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified command ID isn't valid. Verify the ID and try again. /// /// /// The specified key isn't valid. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The specified token isn't valid. /// /// REST API Reference for ListCommandInvocations Operation public virtual Task ListCommandInvocationsAsync(string commandId, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new ListCommandInvocationsRequest(); request.CommandId = commandId; return ListCommandInvocationsAsync(request, cancellationToken); } ///

/// Container for the necessary parameters to execute the ListCommandInvocations service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListCommandInvocations service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified command ID isn't valid. Verify the ID and try again. /// /// /// The specified key isn't valid. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The specified token isn't valid. /// /// REST API Reference for ListCommandInvocations Operation public virtual Task ListCommandInvocationsAsync(ListCommandInvocationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListCommandInvocationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCommandInvocationsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListCommands internal virtual ListCommandsResponse ListCommands() { return ListCommands(new ListCommandsRequest()); } internal virtual ListCommandsResponse ListCommands(ListCommandsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListCommandsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCommandsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListCommands service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified command ID isn't valid. Verify the ID and try again. /// /// /// The specified key isn't valid. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The specified token isn't valid. /// /// REST API Reference for ListCommands Operation public virtual Task ListCommandsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return ListCommandsAsync(new ListCommandsRequest(), cancellationToken); } ///

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

/// (Optional) If provided, lists only the specified command. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListCommands service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified command ID isn't valid. Verify the ID and try again. /// /// /// The specified key isn't valid. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The specified token isn't valid. /// /// REST API Reference for ListCommands Operation public virtual Task ListCommandsAsync(string commandId, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new ListCommandsRequest(); request.CommandId = commandId; return ListCommandsAsync(request, cancellationToken); } ///

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

/// Container for the necessary parameters to execute the ListCommands service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListCommands service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified command ID isn't valid. Verify the ID and try again. /// /// /// The specified key isn't valid. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The specified token isn't valid. /// /// REST API Reference for ListCommands Operation public virtual Task ListCommandsAsync(ListCommandsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListCommandsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCommandsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListComplianceItems internal virtual ListComplianceItemsResponse ListComplianceItems(ListComplianceItemsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListComplianceItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListComplianceItemsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the ListComplianceItems service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListComplianceItems service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The filter name isn't valid. Verify the you entered the correct name and try again. /// /// /// The specified token isn't valid. /// /// /// The resource ID isn't valid. Verify that you entered the correct ID and try again. /// /// /// The resource type isn't valid. For example, if you are attempting to tag an EC2 instance, /// the instance must be a registered managed node. /// /// REST API Reference for ListComplianceItems Operation public virtual Task ListComplianceItemsAsync(ListComplianceItemsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListComplianceItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListComplianceItemsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListComplianceSummaries internal virtual ListComplianceSummariesResponse ListComplianceSummaries(ListComplianceSummariesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListComplianceSummariesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListComplianceSummariesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the ListComplianceSummaries service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListComplianceSummaries service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The filter name isn't valid. Verify the you entered the correct name and try again. /// /// /// The specified token isn't valid. /// /// REST API Reference for ListComplianceSummaries Operation public virtual Task ListComplianceSummariesAsync(ListComplianceSummariesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListComplianceSummariesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListComplianceSummariesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListDocumentMetadataHistory internal virtual ListDocumentMetadataHistoryResponse ListDocumentMetadataHistory(ListDocumentMetadataHistoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListDocumentMetadataHistoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDocumentMetadataHistoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ListDocumentMetadataHistory service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListDocumentMetadataHistory service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The document version isn't valid or doesn't exist. /// /// /// The specified token isn't valid. /// /// REST API Reference for ListDocumentMetadataHistory Operation public virtual Task ListDocumentMetadataHistoryAsync(ListDocumentMetadataHistoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListDocumentMetadataHistoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDocumentMetadataHistoryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListDocuments internal virtual ListDocumentsResponse ListDocuments() { return ListDocuments(new ListDocumentsRequest()); } internal virtual ListDocumentsResponse ListDocuments(ListDocumentsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListDocumentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDocumentsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListDocuments service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified key isn't valid. /// /// /// The specified token isn't valid. /// /// REST API Reference for ListDocuments Operation public virtual Task ListDocumentsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return ListDocumentsAsync(new ListDocumentsRequest(), cancellationToken); } ///

/// 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. ///

/// Container for the necessary parameters to execute the ListDocuments service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListDocuments service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified key isn't valid. /// /// /// The specified token isn't valid. /// /// REST API Reference for ListDocuments Operation public virtual Task ListDocumentsAsync(ListDocumentsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListDocumentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDocumentsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListDocumentVersions internal virtual ListDocumentVersionsResponse ListDocumentVersions(ListDocumentVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListDocumentVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDocumentVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// List all versions for a document. ///

/// Container for the necessary parameters to execute the ListDocumentVersions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListDocumentVersions service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The specified token isn't valid. /// /// REST API Reference for ListDocumentVersions Operation public virtual Task ListDocumentVersionsAsync(ListDocumentVersionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListDocumentVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDocumentVersionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListInventoryEntries internal virtual ListInventoryEntriesResponse ListInventoryEntries(ListInventoryEntriesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListInventoryEntriesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListInventoryEntriesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// A list of inventory items returned by the request. ///

/// Container for the necessary parameters to execute the ListInventoryEntries service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListInventoryEntries service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The filter name isn't valid. Verify the you entered the correct name and try again. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The specified token isn't valid. /// /// /// The parameter type name isn't valid. /// /// REST API Reference for ListInventoryEntries Operation public virtual Task ListInventoryEntriesAsync(ListInventoryEntriesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListInventoryEntriesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListInventoryEntriesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListOpsItemEvents internal virtual ListOpsItemEventsResponse ListOpsItemEvents(ListOpsItemEventsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListOpsItemEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListOpsItemEventsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the ListOpsItemEvents service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListOpsItemEvents service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// A specified parameter argument isn't valid. Verify the available arguments and try /// again. /// /// /// The request caused OpsItems to exceed one or more quotas. /// /// /// The specified OpsItem ID doesn't exist. Verify the ID and try again. /// /// REST API Reference for ListOpsItemEvents Operation public virtual Task ListOpsItemEventsAsync(ListOpsItemEventsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListOpsItemEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListOpsItemEventsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListOpsItemRelatedItems internal virtual ListOpsItemRelatedItemsResponse ListOpsItemRelatedItems(ListOpsItemRelatedItemsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListOpsItemRelatedItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListOpsItemRelatedItemsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ListOpsItemRelatedItems service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListOpsItemRelatedItems service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// A specified parameter argument isn't valid. Verify the available arguments and try /// again. /// /// REST API Reference for ListOpsItemRelatedItems Operation public virtual Task ListOpsItemRelatedItemsAsync(ListOpsItemRelatedItemsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListOpsItemRelatedItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListOpsItemRelatedItemsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListOpsMetadata internal virtual ListOpsMetadataResponse ListOpsMetadata(ListOpsMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = ListOpsMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ListOpsMetadata service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListOpsMetadata service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// One of the arguments passed is invalid. /// /// REST API Reference for ListOpsMetadata Operation public virtual Task ListOpsMetadataAsync(ListOpsMetadataRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = ListOpsMetadataResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListResourceComplianceSummaries internal virtual ListResourceComplianceSummariesResponse ListResourceComplianceSummaries(ListResourceComplianceSummariesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListResourceComplianceSummariesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListResourceComplianceSummariesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the ListResourceComplianceSummaries service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListResourceComplianceSummaries service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The filter name isn't valid. Verify the you entered the correct name and try again. /// /// /// The specified token isn't valid. /// /// REST API Reference for ListResourceComplianceSummaries Operation public virtual Task ListResourceComplianceSummariesAsync(ListResourceComplianceSummariesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListResourceComplianceSummariesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListResourceComplianceSummariesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListResourceDataSync internal virtual ListResourceDataSyncResponse ListResourceDataSync(ListResourceDataSyncRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = ListResourceDataSyncResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the ListResourceDataSync service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListResourceDataSync service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified token isn't valid. /// /// /// The specified sync configuration is invalid. /// /// REST API Reference for ListResourceDataSync Operation public virtual Task ListResourceDataSyncAsync(ListResourceDataSyncRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = ListResourceDataSyncResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListTagsForResource internal virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Returns a list of the tags assigned to the specified resource. /// /// /// /// For information about the ID format for each supported resource type, see AddTagsToResource. /// ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListTagsForResource service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The resource ID isn't valid. Verify that you entered the correct ID and try again. /// /// /// The resource type isn't valid. For example, if you are attempting to tag an EC2 instance, /// the instance must be a registered managed node. /// /// REST API Reference for ListTagsForResource Operation public virtual Task ListTagsForResourceAsync(ListTagsForResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ModifyDocumentPermission internal virtual ModifyDocumentPermissionResponse ModifyDocumentPermission(ModifyDocumentPermissionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDocumentPermissionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDocumentPermissionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the ModifyDocumentPermission service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ModifyDocumentPermission service method, as returned by SimpleSystemsManagement. /// /// You can have at most 500 active SSM documents. /// /// /// The document can't be shared with more Amazon Web Services accounts. You can specify /// a maximum of 20 accounts per API operation to share a private document. /// /// /// /// By default, you can share a private document with a maximum of 1,000 accounts and /// publicly share up to five documents. /// /// /// /// If you need to increase the quota for privately or publicly shared Systems Manager /// documents, contact Amazon Web Services Support. /// /// /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The permission type isn't supported. Share is the only supported permission /// type. /// /// REST API Reference for ModifyDocumentPermission Operation public virtual Task ModifyDocumentPermissionAsync(ModifyDocumentPermissionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDocumentPermissionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDocumentPermissionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region PutComplianceItems internal virtual PutComplianceItemsResponse PutComplianceItems(PutComplianceItemsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutComplianceItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = PutComplianceItemsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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' /// ///

///

/// Container for the necessary parameters to execute the PutComplianceItems service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the PutComplianceItems service method, as returned by SimpleSystemsManagement. /// /// You specified too many custom compliance types. You can specify a maximum of 10 different /// types. /// /// /// An error occurred on the server side. /// /// /// One or more content items isn't valid. /// /// /// The resource ID isn't valid. Verify that you entered the correct ID and try again. /// /// /// The resource type isn't valid. For example, if you are attempting to tag an EC2 instance, /// the instance must be a registered managed node. /// /// /// The inventory item size has exceeded the size limit. /// /// /// The size of inventory data has exceeded the total size limit for the resource. /// /// REST API Reference for PutComplianceItems Operation public virtual Task PutComplianceItemsAsync(PutComplianceItemsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = PutComplianceItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = PutComplianceItemsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region PutInventory internal virtual PutInventoryResponse PutInventory(PutInventoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = PutInventoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the PutInventory service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the PutInventory service method, as returned by SimpleSystemsManagement. /// /// You have exceeded the limit for custom schemas. Delete one or more custom schemas /// and try again. /// /// /// An error occurred on the server side. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// You specified invalid keys or values in the Context attribute for InventoryItem. /// Verify the keys and values, and try again. /// /// /// One or more content items isn't valid. /// /// /// The parameter type name isn't valid. /// /// /// The inventory item has invalid content. /// /// /// The inventory item size has exceeded the size limit. /// /// /// The sub-type count exceeded the limit for the inventory type. /// /// /// The size of inventory data has exceeded the total size limit for the resource. /// /// /// The Context attribute that you specified for the InventoryItem /// isn't allowed for this inventory type. You can only use the Context attribute /// with inventory types like AWS:ComplianceItem. /// /// /// Inventory item type schema version has to match supported versions in the service. /// Check output of GetInventorySchema to see the available schema version for each type. /// /// REST API Reference for PutInventory Operation public virtual Task PutInventoryAsync(PutInventoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = PutInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = PutInventoryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region PutParameter internal virtual PutParameterResponse PutParameter(PutParameterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutParameterRequestMarshaller.Instance; options.ResponseUnmarshaller = PutParameterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Add a parameter to the system. ///

/// Container for the necessary parameters to execute the PutParameter service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the PutParameter service method, as returned by SimpleSystemsManagement. /// /// A hierarchy can have a maximum of 15 levels. For more information, see Requirements /// and constraints for parameter names in the Amazon Web Services Systems Manager /// User Guide. /// /// /// Parameter Store doesn't support changing a parameter type in a hierarchy. For example, /// you can't change a parameter from a String type to a SecureString /// type. You must create a new, unique parameter. /// /// /// There is a conflict in the policies specified for this parameter. You can't, for example, /// specify two Expiration policies for a parameter. Review your policies, and try again. /// /// /// An error occurred on the server side. /// /// /// The request doesn't meet the regular expression requirement. /// /// /// The query key ID isn't valid. /// /// /// A policy attribute or its value is invalid. /// /// /// The policy type isn't supported. Parameter Store supports the following policy types: /// Expiration, ExpirationNotification, and NoChangeNotification. /// /// /// The parameter already exists. You can't create duplicate parameters. /// /// /// You have exceeded the number of parameters for this Amazon Web Services account. Delete /// one or more parameters and try again. /// /// /// Parameter Store retains the 100 most recently created versions of a parameter. After /// this number of versions has been created, Parameter Store deletes the oldest version /// when a new one is created. However, if the oldest version has a label attached /// to it, Parameter Store won't delete the version and instead presents this error message: /// /// /// ///

An error occurred (ParameterMaxVersionLimitExceeded) when calling the PutParameter
        /// operation: You attempted to create a new version of parameter-name by calling
        /// the PutParameter API with the overwrite flag. Version version-number, the oldest
        /// version, can't be deleted because it has a label associated with it. Move the label
        /// to another version of the parameter, and try again.

/// /// /// /// This safeguard is to prevent parameter versions with mission critical labels assigned /// to them from being deleted. To continue creating new parameters, first move the label /// from the oldest version of the parameter to a newer one for use in your operations. /// For information about moving parameter labels, see Move /// a parameter label (console) or Move /// a parameter label (CLI) in the Amazon Web Services Systems Manager User Guide. /// /// /// /// /// The parameter name isn't valid. /// /// /// You specified more than the maximum number of allowed policies for the parameter. /// The maximum is 10. /// /// /// There are concurrent updates for a resource that supports one update at a time. /// /// /// The parameter type isn't supported. /// /// REST API Reference for PutParameter Operation public virtual Task PutParameterAsync(PutParameterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = PutParameterRequestMarshaller.Instance; options.ResponseUnmarshaller = PutParameterResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region PutResourcePolicy internal virtual PutResourcePolicyResponse PutResourcePolicy(PutResourcePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutResourcePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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). ///

/// Container for the necessary parameters to execute the PutResourcePolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the PutResourcePolicy service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The hash provided in the call doesn't match the stored hash. This exception is thrown /// when trying to update an obsolete policy version or when multiple requests to update /// a policy are sent. /// /// /// One or more parameters specified for the call aren't valid. Verify the parameters /// and their values and try again. /// /// /// The PutResourcePolicy API action enforces two limits. A policy can't be greater /// than 1024 bytes in size. And only one policy can be attached to OpsItemGroup. /// Verify these limits and try again. /// /// REST API Reference for PutResourcePolicy Operation public virtual Task PutResourcePolicyAsync(PutResourcePolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = PutResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutResourcePolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RegisterDefaultPatchBaseline internal virtual RegisterDefaultPatchBaselineResponse RegisterDefaultPatchBaseline(RegisterDefaultPatchBaselineRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterDefaultPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterDefaultPatchBaselineResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the RegisterDefaultPatchBaseline service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RegisterDefaultPatchBaseline service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// /// The resource ID isn't valid. Verify that you entered the correct ID and try again. /// /// REST API Reference for RegisterDefaultPatchBaseline Operation public virtual Task RegisterDefaultPatchBaselineAsync(RegisterDefaultPatchBaselineRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterDefaultPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterDefaultPatchBaselineResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RegisterPatchBaselineForPatchGroup internal virtual RegisterPatchBaselineForPatchGroupResponse RegisterPatchBaselineForPatchGroup(RegisterPatchBaselineForPatchGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterPatchBaselineForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterPatchBaselineForPatchGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Registers a patch baseline for a patch group. ///

/// Container for the necessary parameters to execute the RegisterPatchBaselineForPatchGroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RegisterPatchBaselineForPatchGroup service method, as returned by SimpleSystemsManagement. /// /// Error returned if an attempt is made to register a patch group with a patch baseline /// that is already registered with a different patch baseline. /// /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// /// The resource ID isn't valid. Verify that you entered the correct ID and try again. /// /// /// Error returned when the caller has exceeded the default resource quotas. For example, /// too many maintenance windows or patch baselines have been created. /// /// /// /// For information about resource quotas in Systems Manager, see Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// REST API Reference for RegisterPatchBaselineForPatchGroup Operation public virtual Task RegisterPatchBaselineForPatchGroupAsync(RegisterPatchBaselineForPatchGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterPatchBaselineForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterPatchBaselineForPatchGroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RegisterTargetWithMaintenanceWindow internal virtual RegisterTargetWithMaintenanceWindowResponse RegisterTargetWithMaintenanceWindow(RegisterTargetWithMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterTargetWithMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterTargetWithMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Registers a target with a maintenance window. ///

/// Container for the necessary parameters to execute the RegisterTargetWithMaintenanceWindow service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RegisterTargetWithMaintenanceWindow service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// Error returned when an idempotent operation is retried and the parameters don't match /// the original call to the API with the same idempotency token. /// /// /// An error occurred on the server side. /// /// /// Error returned when the caller has exceeded the default resource quotas. For example, /// too many maintenance windows or patch baselines have been created. /// /// /// /// For information about resource quotas in Systems Manager, see Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// REST API Reference for RegisterTargetWithMaintenanceWindow Operation public virtual Task RegisterTargetWithMaintenanceWindowAsync(RegisterTargetWithMaintenanceWindowRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterTargetWithMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterTargetWithMaintenanceWindowResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RegisterTaskWithMaintenanceWindow internal virtual RegisterTaskWithMaintenanceWindowResponse RegisterTaskWithMaintenanceWindow(RegisterTaskWithMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterTaskWithMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterTaskWithMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Adds a new task to a maintenance window. ///

/// Container for the necessary parameters to execute the RegisterTaskWithMaintenanceWindow service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RegisterTaskWithMaintenanceWindow service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// You attempted to register a LAMBDA or STEP_FUNCTIONS task /// in a region where the corresponding service isn't available. /// /// /// Error returned when an idempotent operation is retried and the parameters don't match /// the original call to the API with the same idempotency token. /// /// /// An error occurred on the server side. /// /// /// Error returned when the caller has exceeded the default resource quotas. For example, /// too many maintenance windows or patch baselines have been created. /// /// /// /// For information about resource quotas in Systems Manager, see Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// REST API Reference for RegisterTaskWithMaintenanceWindow Operation public virtual Task RegisterTaskWithMaintenanceWindowAsync(RegisterTaskWithMaintenanceWindowRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterTaskWithMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterTaskWithMaintenanceWindowResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RemoveTagsFromResource internal virtual RemoveTagsFromResourceResponse RemoveTagsFromResource(RemoveTagsFromResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveTagsFromResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveTagsFromResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Removes tag keys from the specified resource. ///

/// Container for the necessary parameters to execute the RemoveTagsFromResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RemoveTagsFromResource service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The resource ID isn't valid. Verify that you entered the correct ID and try again. /// /// /// The resource type isn't valid. For example, if you are attempting to tag an EC2 instance, /// the instance must be a registered managed node. /// /// /// There are concurrent updates for a resource that supports one update at a time. /// /// REST API Reference for RemoveTagsFromResource Operation public virtual Task RemoveTagsFromResourceAsync(RemoveTagsFromResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveTagsFromResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveTagsFromResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ResetServiceSetting internal virtual ResetServiceSettingResponse ResetServiceSetting(ResetServiceSettingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ResetServiceSettingRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetServiceSettingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the ResetServiceSetting service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ResetServiceSetting service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified service setting wasn't found. Either the service name or the setting /// hasn't been provisioned by the Amazon Web Services service team. /// /// /// There are concurrent updates for a resource that supports one update at a time. /// /// REST API Reference for ResetServiceSetting Operation public virtual Task ResetServiceSettingAsync(ResetServiceSettingRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ResetServiceSettingRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetServiceSettingResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ResumeSession internal virtual ResumeSessionResponse ResumeSession(ResumeSessionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ResumeSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = ResumeSessionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the ResumeSession service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ResumeSession service method, as returned by SimpleSystemsManagement. /// /// Error returned when the ID specified for a resource, such as a maintenance window /// or patch baseline, doesn't exist. /// /// /// /// For information about resource quotas in Amazon Web Services Systems Manager, see /// Systems /// Manager service quotas in the Amazon Web Services General Reference. /// /// /// /// An error occurred on the server side. /// /// REST API Reference for ResumeSession Operation public virtual Task ResumeSessionAsync(ResumeSessionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ResumeSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = ResumeSessionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region SendAutomationSignal internal virtual SendAutomationSignalResponse SendAutomationSignal(SendAutomationSignalRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SendAutomationSignalRequestMarshaller.Instance; options.ResponseUnmarshaller = SendAutomationSignalResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the SendAutomationSignal service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SendAutomationSignal service method, as returned by SimpleSystemsManagement. /// /// There is no automation execution information for the requested automation execution /// ID. /// /// /// The specified step name and execution ID don't exist. Verify the information and try /// again. /// /// /// An error occurred on the server side. /// /// /// The signal isn't valid for the current Automation execution. /// /// REST API Reference for SendAutomationSignal Operation public virtual Task SendAutomationSignalAsync(SendAutomationSignalRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = SendAutomationSignalRequestMarshaller.Instance; options.ResponseUnmarshaller = SendAutomationSignalResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region SendCommand internal virtual SendCommandResponse SendCommand(SendCommandRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SendCommandRequestMarshaller.Instance; options.ResponseUnmarshaller = SendCommandResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Runs commands on one or more managed nodes. ///

/// The name of the Amazon Web Services Systems Manager document (SSM document) to run. This can be a public document or a custom document. To run a shared document belonging to another account, specify the document Amazon Resource Name (ARN). For more information about how to use shared documents, see Using shared SSM documents in the Amazon Web Services Systems Manager User Guide. If you specify a document name or ARN that hasn't been shared with your account, you receive an InvalidDocument error. /// The IDs of the managed nodes where the command should run. Specifying managed node IDs is most useful when you are targeting a limited number of managed nodes, though you can specify up to 50 IDs. To target a larger number of managed nodes, or if you prefer not to list individual node IDs, we recommend using the Targets option instead. Using Targets, which accepts tag key-value pairs to identify the managed nodes to send commands to, you can a send command to tens, hundreds, or thousands of nodes at once. For more information about how to use targets, see Using targets and rate controls to send commands to a fleet in the Amazon Web Services Systems Manager User Guide. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SendCommand service method, as returned by SimpleSystemsManagement. /// /// You can't specify a managed node ID in more than one association. /// /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The document version isn't valid or doesn't exist. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// One or more configuration items isn't valid. Verify that a valid Amazon Resource Name /// (ARN) was provided for an Amazon Simple Notification Service topic. /// /// /// The S3 bucket doesn't exist. /// /// /// You must specify values for all required parameters in the Amazon Web Services Systems /// Manager document (SSM document). You can only supply values to parameters defined /// in the SSM document. /// /// /// The role name can't contain invalid characters. Also verify that you specified an /// IAM role for notifications that includes the required trust policy. For information /// about configuring the IAM role for Run Command notifications, see Configuring /// Amazon SNS Notifications for Run Command in the Amazon Web Services Systems /// Manager User Guide. /// /// /// The size limit of a document is 64 KB. /// /// /// The document doesn't support the platform type of the given managed node ID(s). For /// example, you sent an document for a Windows managed node to a Linux node. /// /// REST API Reference for SendCommand Operation public virtual Task SendCommandAsync(string documentName, List instanceIds, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new SendCommandRequest(); request.DocumentName = documentName; request.InstanceIds = instanceIds; return SendCommandAsync(request, cancellationToken); } ///

/// Runs commands on one or more managed nodes. ///

/// Container for the necessary parameters to execute the SendCommand service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the SendCommand service method, as returned by SimpleSystemsManagement. /// /// You can't specify a managed node ID in more than one association. /// /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The document version isn't valid or doesn't exist. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// One or more configuration items isn't valid. Verify that a valid Amazon Resource Name /// (ARN) was provided for an Amazon Simple Notification Service topic. /// /// /// The S3 bucket doesn't exist. /// /// /// You must specify values for all required parameters in the Amazon Web Services Systems /// Manager document (SSM document). You can only supply values to parameters defined /// in the SSM document. /// /// /// The role name can't contain invalid characters. Also verify that you specified an /// IAM role for notifications that includes the required trust policy. For information /// about configuring the IAM role for Run Command notifications, see Configuring /// Amazon SNS Notifications for Run Command in the Amazon Web Services Systems /// Manager User Guide. /// /// /// The size limit of a document is 64 KB. /// /// /// The document doesn't support the platform type of the given managed node ID(s). For /// example, you sent an document for a Windows managed node to a Linux node. /// /// REST API Reference for SendCommand Operation public virtual Task SendCommandAsync(SendCommandRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = SendCommandRequestMarshaller.Instance; options.ResponseUnmarshaller = SendCommandResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region StartAssociationsOnce internal virtual StartAssociationsOnceResponse StartAssociationsOnce(StartAssociationsOnceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartAssociationsOnceRequestMarshaller.Instance; options.ResponseUnmarshaller = StartAssociationsOnceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the StartAssociationsOnce service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the StartAssociationsOnce service method, as returned by SimpleSystemsManagement. /// /// The specified association doesn't exist. /// /// /// The association isn't valid or doesn't exist. /// /// REST API Reference for StartAssociationsOnce Operation public virtual Task StartAssociationsOnceAsync(StartAssociationsOnceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = StartAssociationsOnceRequestMarshaller.Instance; options.ResponseUnmarshaller = StartAssociationsOnceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region StartAutomationExecution internal virtual StartAutomationExecutionResponse StartAutomationExecution(StartAutomationExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartAutomationExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartAutomationExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates execution of an Automation runbook. ///

/// Container for the necessary parameters to execute the StartAutomationExecution service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the StartAutomationExecution service method, as returned by SimpleSystemsManagement. /// /// An Automation runbook with the specified name couldn't be found. /// /// /// An Automation runbook with the specified name and version couldn't be found. /// /// /// The number of simultaneously running Automation executions exceeded the allowable /// limit. /// /// /// Error returned when an idempotent operation is retried and the parameters don't match /// the original call to the API with the same idempotency token. /// /// /// An error occurred on the server side. /// /// /// The supplied parameters for invoking the specified Automation runbook are incorrect. /// For example, they may not match the set of parameters permitted for the specified /// Automation document. /// /// /// The target isn't valid or doesn't exist. It might not be configured for Systems Manager /// or you might not have permission to perform the operation. /// /// REST API Reference for StartAutomationExecution Operation public virtual Task StartAutomationExecutionAsync(StartAutomationExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = StartAutomationExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartAutomationExecutionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region StartChangeRequestExecution internal virtual StartChangeRequestExecutionResponse StartChangeRequestExecution(StartChangeRequestExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartChangeRequestExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartChangeRequestExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the StartChangeRequestExecution service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the StartChangeRequestExecution service method, as returned by SimpleSystemsManagement. /// /// Indicates that the Change Manager change template used in the change request was rejected /// or is still in a pending state. /// /// /// An Automation runbook with the specified name couldn't be found. /// /// /// An Automation runbook with the specified name and version couldn't be found. /// /// /// The number of simultaneously running Automation executions exceeded the allowable /// limit. /// /// /// Error returned when an idempotent operation is retried and the parameters don't match /// the original call to the API with the same idempotency token. /// /// /// An error occurred on the server side. /// /// /// The supplied parameters for invoking the specified Automation runbook are incorrect. /// For example, they may not match the set of parameters permitted for the specified /// Automation document. /// /// REST API Reference for StartChangeRequestExecution Operation public virtual Task StartChangeRequestExecutionAsync(StartChangeRequestExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = StartChangeRequestExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartChangeRequestExecutionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region StartSession internal virtual StartSessionResponse StartSession(StartSessionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartSessionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the StartSession service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the StartSession service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The specified target managed node for the session isn't fully configured for use with /// Session Manager. For more information, see Getting /// started with Session Manager in the Amazon Web Services Systems Manager User /// Guide. This error is also returned if you attempt to start a session on a managed /// node that is located in a different account or Region /// /// REST API Reference for StartSession Operation public virtual Task StartSessionAsync(StartSessionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = StartSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartSessionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region StopAutomationExecution internal virtual StopAutomationExecutionResponse StopAutomationExecution(StopAutomationExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StopAutomationExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StopAutomationExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Stop an Automation that is currently running. ///

/// Container for the necessary parameters to execute the StopAutomationExecution service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the StopAutomationExecution service method, as returned by SimpleSystemsManagement. /// /// There is no automation execution information for the requested automation execution /// ID. /// /// /// An error occurred on the server side. /// /// /// The specified update status operation isn't valid. /// /// REST API Reference for StopAutomationExecution Operation public virtual Task StopAutomationExecutionAsync(StopAutomationExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = StopAutomationExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StopAutomationExecutionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region TerminateSession internal virtual TerminateSessionResponse TerminateSession(TerminateSessionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TerminateSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = TerminateSessionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. ///

/// Container for the necessary parameters to execute the TerminateSession service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the TerminateSession service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// REST API Reference for TerminateSession Operation public virtual Task TerminateSessionAsync(TerminateSessionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = TerminateSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = TerminateSessionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UnlabelParameterVersion internal virtual UnlabelParameterVersionResponse UnlabelParameterVersion(UnlabelParameterVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UnlabelParameterVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = UnlabelParameterVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Remove a label or labels from a parameter. ///

/// Container for the necessary parameters to execute the UnlabelParameterVersion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the UnlabelParameterVersion service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The parameter couldn't be found. Verify the name and try again. /// /// /// The specified parameter version wasn't found. Verify the parameter name and version, /// and try again. /// /// /// There are concurrent updates for a resource that supports one update at a time. /// /// REST API Reference for UnlabelParameterVersion Operation public virtual Task UnlabelParameterVersionAsync(UnlabelParameterVersionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UnlabelParameterVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = UnlabelParameterVersionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateAssociation internal virtual UpdateAssociationResponse UpdateAssociation(UpdateAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// ///

/// Container for the necessary parameters to execute the UpdateAssociation service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the UpdateAssociation service method, as returned by SimpleSystemsManagement. /// /// The specified association doesn't exist. /// /// /// You have reached the maximum number versions allowed for an association. Each association /// has a limit of 1,000 versions. /// /// /// An error occurred on the server side. /// /// /// The version you specified isn't valid. Use ListAssociationVersions to view all versions /// of an association according to the association ID. Or, use the $LATEST /// parameter to view the latest version of the association. /// /// /// The specified SSM document doesn't exist. /// /// /// The document version isn't valid or doesn't exist. /// /// /// The output location isn't valid or doesn't exist. /// /// /// You must specify values for all required parameters in the Amazon Web Services Systems /// Manager document (SSM document). You can only supply values to parameters defined /// in the SSM document. /// /// /// The schedule is invalid. Verify your cron or rate expression and try again. /// /// /// The target isn't valid or doesn't exist. It might not be configured for Systems Manager /// or you might not have permission to perform the operation. /// /// /// TargetMap parameter isn't valid. /// /// /// The update isn't valid. /// /// /// There are concurrent updates for a resource that supports one update at a time. /// /// REST API Reference for UpdateAssociation Operation public virtual Task UpdateAssociationAsync(UpdateAssociationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAssociationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateAssociationStatus internal virtual UpdateAssociationStatusResponse UpdateAssociationStatus(UpdateAssociationStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAssociationStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAssociationStatusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// Container for the necessary parameters to execute the UpdateAssociationStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the UpdateAssociationStatus service method, as returned by SimpleSystemsManagement. /// /// The specified association doesn't exist. /// /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The following problems can cause this exception: /// ///

/// /// You don't have permission to access the managed node. /// ///
/// /// Amazon Web Services Systems Manager Agent(SSM Agent) isn't running. Verify that SSM /// Agent is running. /// ///
/// /// SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent. /// ///
/// /// The managed node isn't in valid state. Valid states are: Running, Pending, /// Stopped, and Stopping. Invalid states are: Shutting-down /// and Terminated. /// ///

/// /// /// The updated status is the same as the current status. /// /// /// There are concurrent updates for a resource that supports one update at a time. /// /// REST API Reference for UpdateAssociationStatus Operation public virtual Task UpdateAssociationStatusAsync(UpdateAssociationStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAssociationStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAssociationStatusResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateDocument internal virtual UpdateDocumentResponse UpdateDocument(UpdateDocumentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDocumentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Updates one or more values for an SSM document. ///

/// Container for the necessary parameters to execute the UpdateDocument service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the UpdateDocument service method, as returned by SimpleSystemsManagement. /// /// The document has too many versions. Delete one or more document versions and try again. /// /// /// The content of the association document matches another document. Change the content /// of the document and try again. /// /// /// The version name has already been used in this document. Specify a different version /// name, and then try again. /// /// /// An error occurred on the server side. /// /// /// The content for the document isn't valid. /// /// /// The specified SSM document doesn't exist. /// /// /// You attempted to delete a document while it is still shared. You must stop sharing /// the document before you can delete it. /// /// /// The version of the document schema isn't supported. /// /// /// The document version isn't valid or doesn't exist. /// /// /// The size limit of a document is 64 KB. /// /// REST API Reference for UpdateDocument Operation public virtual Task UpdateDocumentAsync(UpdateDocumentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDocumentResponseUnmarshaller.Instance; return InvokeAsync