/* * 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.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(); #if BCL45 || 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 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 #region Overrides ///

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

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

/// Customize the pipeline ///

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

/// 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. /// /// 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 AddTagsToResourceResponse AddTagsToResource(AddTagsToResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddTagsToResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddTagsToResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AddTagsToResource operation. ///

/// /// Container for the necessary parameters to execute the AddTagsToResource operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAddTagsToResource /// operation. /// REST API Reference for AddTagsToResource Operation public virtual IAsyncResult BeginAddTagsToResource(AddTagsToResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AddTagsToResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddTagsToResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AddTagsToResource operation. ///

/// /// The IAsyncResult returned by the call to BeginAddTagsToResource. /// /// Returns a AddTagsToResourceResult from SimpleSystemsManagement. /// REST API Reference for AddTagsToResource Operation public virtual AddTagsToResourceResponse EndAddTagsToResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AssociateOpsItemRelatedItem ///

/// 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. /// /// 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 AssociateOpsItemRelatedItemResponse AssociateOpsItemRelatedItem(AssociateOpsItemRelatedItemRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateOpsItemRelatedItemRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateOpsItemRelatedItemResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AssociateOpsItemRelatedItem operation. ///

/// /// Container for the necessary parameters to execute the AssociateOpsItemRelatedItem operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateOpsItemRelatedItem /// operation. /// REST API Reference for AssociateOpsItemRelatedItem Operation public virtual IAsyncResult BeginAssociateOpsItemRelatedItem(AssociateOpsItemRelatedItemRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateOpsItemRelatedItemRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateOpsItemRelatedItemResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AssociateOpsItemRelatedItem operation. ///

/// /// The IAsyncResult returned by the call to BeginAssociateOpsItemRelatedItem. /// /// Returns a AssociateOpsItemRelatedItemResult from SimpleSystemsManagement. /// REST API Reference for AssociateOpsItemRelatedItem Operation public virtual AssociateOpsItemRelatedItemResponse EndAssociateOpsItemRelatedItem(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CancelCommand ///

/// 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. /// /// 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 CancelCommandResponse CancelCommand(string commandId) { var request = new CancelCommandRequest(); request.CommandId = commandId; return CancelCommand(request); } ///

/// 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. /// /// 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 CancelCommandResponse CancelCommand(string commandId, List instanceIds) { var request = new CancelCommandRequest(); request.CommandId = commandId; request.InstanceIds = instanceIds; return CancelCommand(request); } ///

/// 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. /// /// 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 CancelCommandResponse CancelCommand(CancelCommandRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelCommandRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelCommandResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CancelCommand operation. ///

/// /// Container for the necessary parameters to execute the CancelCommand operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelCommand /// operation. /// REST API Reference for CancelCommand Operation public virtual IAsyncResult BeginCancelCommand(CancelCommandRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CancelCommandRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelCommandResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CancelCommand operation. ///

/// /// The IAsyncResult returned by the call to BeginCancelCommand. /// /// Returns a CancelCommandResult from SimpleSystemsManagement. /// REST API Reference for CancelCommand Operation public virtual CancelCommandResponse EndCancelCommand(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CancelMaintenanceWindowExecution ///

/// 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. /// /// 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 CancelMaintenanceWindowExecutionResponse CancelMaintenanceWindowExecution(CancelMaintenanceWindowExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelMaintenanceWindowExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelMaintenanceWindowExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CancelMaintenanceWindowExecution operation. ///

/// /// Container for the necessary parameters to execute the CancelMaintenanceWindowExecution operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelMaintenanceWindowExecution /// operation. /// REST API Reference for CancelMaintenanceWindowExecution Operation public virtual IAsyncResult BeginCancelMaintenanceWindowExecution(CancelMaintenanceWindowExecutionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CancelMaintenanceWindowExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelMaintenanceWindowExecutionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CancelMaintenanceWindowExecution operation. ///

/// /// The IAsyncResult returned by the call to BeginCancelMaintenanceWindowExecution. /// /// Returns a CancelMaintenanceWindowExecutionResult from SimpleSystemsManagement. /// REST API Reference for CancelMaintenanceWindowExecution Operation public virtual CancelMaintenanceWindowExecutionResponse EndCancelMaintenanceWindowExecution(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateActivation ///

/// 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. /// /// 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 CreateActivationResponse CreateActivation(CreateActivationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateActivationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateActivationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateActivation operation. ///

/// /// Container for the necessary parameters to execute the CreateActivation operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateActivation /// operation. /// REST API Reference for CreateActivation Operation public virtual IAsyncResult BeginCreateActivation(CreateActivationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateActivationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateActivationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateActivation operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateActivation. /// /// Returns a CreateActivationResult from SimpleSystemsManagement. /// REST API Reference for CreateActivation Operation public virtual CreateActivationResponse EndCreateActivation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateAssociation ///

/// 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. /// /// 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 CreateAssociationResponse CreateAssociation(string instanceId, string name) { var request = new CreateAssociationRequest(); request.InstanceId = instanceId; request.Name = name; return CreateAssociation(request); } ///

/// Container for the necessary parameters to execute the CreateAssociation service method. /// /// 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 CreateAssociationResponse CreateAssociation(CreateAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateAssociation operation. ///

/// /// Container for the necessary parameters to execute the CreateAssociation operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateAssociation /// operation. /// REST API Reference for CreateAssociation Operation public virtual IAsyncResult BeginCreateAssociation(CreateAssociationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAssociationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateAssociation operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateAssociation. /// /// Returns a CreateAssociationResult from SimpleSystemsManagement. /// REST API Reference for CreateAssociation Operation public virtual CreateAssociationResponse EndCreateAssociation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateAssociationBatch ///

/// 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. /// /// 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 CreateAssociationBatchResponse CreateAssociationBatch(CreateAssociationBatchRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAssociationBatchRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAssociationBatchResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateAssociationBatch operation. ///

/// /// Container for the necessary parameters to execute the CreateAssociationBatch operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateAssociationBatch /// operation. /// REST API Reference for CreateAssociationBatch Operation public virtual IAsyncResult BeginCreateAssociationBatch(CreateAssociationBatchRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAssociationBatchRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAssociationBatchResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateAssociationBatch operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateAssociationBatch. /// /// Returns a CreateAssociationBatchResult from SimpleSystemsManagement. /// REST API Reference for CreateAssociationBatch Operation public virtual CreateAssociationBatchResponse EndCreateAssociationBatch(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateDocument ///

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

/// /// 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 CreateDocumentResponse CreateDocument(string content, string name) { var request = new CreateDocumentRequest(); request.Content = content; request.Name = name; return CreateDocument(request); } ///

/// Container for the necessary parameters to execute the CreateDocument service method. /// /// 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 CreateDocumentResponse CreateDocument(CreateDocumentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDocumentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateDocument operation. ///

/// /// Container for the necessary parameters to execute the CreateDocument operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDocument /// operation. /// REST API Reference for CreateDocument Operation public virtual IAsyncResult BeginCreateDocument(CreateDocumentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDocumentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateDocument operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateDocument. /// /// Returns a CreateDocumentResult from SimpleSystemsManagement. /// REST API Reference for CreateDocument Operation public virtual CreateDocumentResponse EndCreateDocument(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateMaintenanceWindow ///

/// 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. /// /// 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 CreateMaintenanceWindowResponse CreateMaintenanceWindow(CreateMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateMaintenanceWindow operation. ///

/// /// Container for the necessary parameters to execute the CreateMaintenanceWindow operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateMaintenanceWindow /// operation. /// REST API Reference for CreateMaintenanceWindow Operation public virtual IAsyncResult BeginCreateMaintenanceWindow(CreateMaintenanceWindowRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMaintenanceWindowResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateMaintenanceWindow operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateMaintenanceWindow. /// /// Returns a CreateMaintenanceWindowResult from SimpleSystemsManagement. /// REST API Reference for CreateMaintenanceWindow Operation public virtual CreateMaintenanceWindowResponse EndCreateMaintenanceWindow(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateOpsItem ///

/// 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. /// /// 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 CreateOpsItemResponse CreateOpsItem(CreateOpsItemRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateOpsItemRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateOpsItemResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateOpsItem operation. ///

/// /// Container for the necessary parameters to execute the CreateOpsItem operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateOpsItem /// operation. /// REST API Reference for CreateOpsItem Operation public virtual IAsyncResult BeginCreateOpsItem(CreateOpsItemRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateOpsItemRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateOpsItemResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateOpsItem operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateOpsItem. /// /// Returns a CreateOpsItemResult from SimpleSystemsManagement. /// REST API Reference for CreateOpsItem Operation public virtual CreateOpsItemResponse EndCreateOpsItem(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateOpsMetadata ///

/// 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. /// /// 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 CreateOpsMetadataResponse CreateOpsMetadata(CreateOpsMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateOpsMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateOpsMetadata operation. ///

/// /// Container for the necessary parameters to execute the CreateOpsMetadata operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateOpsMetadata /// operation. /// REST API Reference for CreateOpsMetadata Operation public virtual IAsyncResult BeginCreateOpsMetadata(CreateOpsMetadataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateOpsMetadataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateOpsMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateOpsMetadata. /// /// Returns a CreateOpsMetadataResult from SimpleSystemsManagement. /// REST API Reference for CreateOpsMetadata Operation public virtual CreateOpsMetadataResponse EndCreateOpsMetadata(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreatePatchBaseline ///

/// 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. /// /// 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 CreatePatchBaselineResponse CreatePatchBaseline(CreatePatchBaselineRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePatchBaselineResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreatePatchBaseline operation. ///

/// /// Container for the necessary parameters to execute the CreatePatchBaseline operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreatePatchBaseline /// operation. /// REST API Reference for CreatePatchBaseline Operation public virtual IAsyncResult BeginCreatePatchBaseline(CreatePatchBaselineRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreatePatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = CreatePatchBaselineResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreatePatchBaseline operation. ///

/// /// The IAsyncResult returned by the call to BeginCreatePatchBaseline. /// /// Returns a CreatePatchBaselineResult from SimpleSystemsManagement. /// REST API Reference for CreatePatchBaseline Operation public virtual CreatePatchBaselineResponse EndCreatePatchBaseline(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateResourceDataSync ///

/// 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. /// /// 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 CreateResourceDataSyncResponse CreateResourceDataSync(CreateResourceDataSyncRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateResourceDataSyncResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateResourceDataSync operation. ///

/// /// Container for the necessary parameters to execute the CreateResourceDataSync operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateResourceDataSync /// operation. /// REST API Reference for CreateResourceDataSync Operation public virtual IAsyncResult BeginCreateResourceDataSync(CreateResourceDataSyncRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateResourceDataSyncResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateResourceDataSync operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateResourceDataSync. /// /// Returns a CreateResourceDataSyncResult from SimpleSystemsManagement. /// REST API Reference for CreateResourceDataSync Operation public virtual CreateResourceDataSyncResponse EndCreateResourceDataSync(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteActivation ///

/// 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. /// /// 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 DeleteActivationResponse DeleteActivation(DeleteActivationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteActivationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteActivationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteActivation operation. ///

/// /// Container for the necessary parameters to execute the DeleteActivation operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteActivation /// operation. /// REST API Reference for DeleteActivation Operation public virtual IAsyncResult BeginDeleteActivation(DeleteActivationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteActivationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteActivationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteActivation operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteActivation. /// /// Returns a DeleteActivationResult from SimpleSystemsManagement. /// REST API Reference for DeleteActivation Operation public virtual DeleteActivationResponse EndDeleteActivation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteAssociation ///

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

/// /// /// There are concurrent updates for a resource that supports one update at a time. /// /// REST API Reference for DeleteAssociation Operation public virtual DeleteAssociationResponse DeleteAssociation(string instanceId, string name) { var request = new DeleteAssociationRequest(); request.InstanceId = instanceId; request.Name = name; return DeleteAssociation(request); } ///

/// Container for the necessary parameters to execute the DeleteAssociation service method. /// /// 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 DeleteAssociationResponse DeleteAssociation(DeleteAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteAssociation operation. ///

/// /// Container for the necessary parameters to execute the DeleteAssociation operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteAssociation /// operation. /// REST API Reference for DeleteAssociation Operation public virtual IAsyncResult BeginDeleteAssociation(DeleteAssociationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteAssociationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteAssociation operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteAssociation. /// /// Returns a DeleteAssociationResult from SimpleSystemsManagement. /// REST API Reference for DeleteAssociation Operation public virtual DeleteAssociationResponse EndDeleteAssociation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteDocument ///

/// 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. /// /// 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 DeleteDocumentResponse DeleteDocument(string name) { var request = new DeleteDocumentRequest(); request.Name = name; return DeleteDocument(request); } ///

/// Container for the necessary parameters to execute the DeleteDocument service method. /// /// 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 DeleteDocumentResponse DeleteDocument(DeleteDocumentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDocumentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteDocument operation. ///

/// /// Container for the necessary parameters to execute the DeleteDocument operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteDocument /// operation. /// REST API Reference for DeleteDocument Operation public virtual IAsyncResult BeginDeleteDocument(DeleteDocumentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDocumentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteDocument operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteDocument. /// /// Returns a DeleteDocumentResult from SimpleSystemsManagement. /// REST API Reference for DeleteDocument Operation public virtual DeleteDocumentResponse EndDeleteDocument(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteInventory ///

/// 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. /// /// 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 DeleteInventoryResponse DeleteInventory(DeleteInventoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteInventoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteInventory operation. ///

/// /// Container for the necessary parameters to execute the DeleteInventory operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteInventory /// operation. /// REST API Reference for DeleteInventory Operation public virtual IAsyncResult BeginDeleteInventory(DeleteInventoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteInventoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteInventory operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteInventory. /// /// Returns a DeleteInventoryResult from SimpleSystemsManagement. /// REST API Reference for DeleteInventory Operation public virtual DeleteInventoryResponse EndDeleteInventory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteMaintenanceWindow ///

/// Deletes a maintenance window. ///

/// Container for the necessary parameters to execute the DeleteMaintenanceWindow service method. /// /// 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 DeleteMaintenanceWindowResponse DeleteMaintenanceWindow(DeleteMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteMaintenanceWindow operation. ///

/// /// Container for the necessary parameters to execute the DeleteMaintenanceWindow operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteMaintenanceWindow /// operation. /// REST API Reference for DeleteMaintenanceWindow Operation public virtual IAsyncResult BeginDeleteMaintenanceWindow(DeleteMaintenanceWindowRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteMaintenanceWindowResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteMaintenanceWindow operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteMaintenanceWindow. /// /// Returns a DeleteMaintenanceWindowResult from SimpleSystemsManagement. /// REST API Reference for DeleteMaintenanceWindow Operation public virtual DeleteMaintenanceWindowResponse EndDeleteMaintenanceWindow(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteOpsMetadata ///

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

/// Container for the necessary parameters to execute the DeleteOpsMetadata service method. /// /// 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 DeleteOpsMetadataResponse DeleteOpsMetadata(DeleteOpsMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteOpsMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteOpsMetadata operation. ///

/// /// Container for the necessary parameters to execute the DeleteOpsMetadata operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteOpsMetadata /// operation. /// REST API Reference for DeleteOpsMetadata Operation public virtual IAsyncResult BeginDeleteOpsMetadata(DeleteOpsMetadataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteOpsMetadataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteOpsMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteOpsMetadata. /// /// Returns a DeleteOpsMetadataResult from SimpleSystemsManagement. /// REST API Reference for DeleteOpsMetadata Operation public virtual DeleteOpsMetadataResponse EndDeleteOpsMetadata(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteParameter ///

/// 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. /// /// 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 DeleteParameterResponse DeleteParameter(DeleteParameterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteParameterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteParameterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteParameter operation. ///

/// /// Container for the necessary parameters to execute the DeleteParameter operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteParameter /// operation. /// REST API Reference for DeleteParameter Operation public virtual IAsyncResult BeginDeleteParameter(DeleteParameterRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteParameterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteParameterResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteParameter operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteParameter. /// /// Returns a DeleteParameterResult from SimpleSystemsManagement. /// REST API Reference for DeleteParameter Operation public virtual DeleteParameterResponse EndDeleteParameter(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteParameters ///

/// 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. /// /// 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 DeleteParametersResponse DeleteParameters(DeleteParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteParameters operation. ///

/// /// Container for the necessary parameters to execute the DeleteParameters operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteParameters /// operation. /// REST API Reference for DeleteParameters Operation public virtual IAsyncResult BeginDeleteParameters(DeleteParametersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteParametersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteParameters operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteParameters. /// /// Returns a DeleteParametersResult from SimpleSystemsManagement. /// REST API Reference for DeleteParameters Operation public virtual DeleteParametersResponse EndDeleteParameters(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeletePatchBaseline ///

/// Deletes a patch baseline. ///

/// Container for the necessary parameters to execute the DeletePatchBaseline service method. /// /// 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 DeletePatchBaselineResponse DeletePatchBaseline(DeletePatchBaselineRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePatchBaselineResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeletePatchBaseline operation. ///

/// /// Container for the necessary parameters to execute the DeletePatchBaseline operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeletePatchBaseline /// operation. /// REST API Reference for DeletePatchBaseline Operation public virtual IAsyncResult BeginDeletePatchBaseline(DeletePatchBaselineRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeletePatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = DeletePatchBaselineResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeletePatchBaseline operation. ///

/// /// The IAsyncResult returned by the call to BeginDeletePatchBaseline. /// /// Returns a DeletePatchBaselineResult from SimpleSystemsManagement. /// REST API Reference for DeletePatchBaseline Operation public virtual DeletePatchBaselineResponse EndDeletePatchBaseline(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteResourceDataSync ///

/// 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. /// /// 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 DeleteResourceDataSyncResponse DeleteResourceDataSync(DeleteResourceDataSyncRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourceDataSyncResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteResourceDataSync operation. ///

/// /// Container for the necessary parameters to execute the DeleteResourceDataSync operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteResourceDataSync /// operation. /// REST API Reference for DeleteResourceDataSync Operation public virtual IAsyncResult BeginDeleteResourceDataSync(DeleteResourceDataSyncRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourceDataSyncResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteResourceDataSync operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteResourceDataSync. /// /// Returns a DeleteResourceDataSyncResult from SimpleSystemsManagement. /// REST API Reference for DeleteResourceDataSync Operation public virtual DeleteResourceDataSyncResponse EndDeleteResourceDataSync(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteResourcePolicy ///

/// 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. /// /// 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 DeleteResourcePolicyResponse DeleteResourcePolicy(DeleteResourcePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourcePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteResourcePolicy operation. ///

/// /// Container for the necessary parameters to execute the DeleteResourcePolicy operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteResourcePolicy /// operation. /// REST API Reference for DeleteResourcePolicy Operation public virtual IAsyncResult BeginDeleteResourcePolicy(DeleteResourcePolicyRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourcePolicyResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteResourcePolicy operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteResourcePolicy. /// /// Returns a DeleteResourcePolicyResult from SimpleSystemsManagement. /// REST API Reference for DeleteResourcePolicy Operation public virtual DeleteResourcePolicyResponse EndDeleteResourcePolicy(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeregisterManagedInstance ///

/// 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. /// /// 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 DeregisterManagedInstanceResponse DeregisterManagedInstance(DeregisterManagedInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterManagedInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterManagedInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeregisterManagedInstance operation. ///

/// /// Container for the necessary parameters to execute the DeregisterManagedInstance operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterManagedInstance /// operation. /// REST API Reference for DeregisterManagedInstance Operation public virtual IAsyncResult BeginDeregisterManagedInstance(DeregisterManagedInstanceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterManagedInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterManagedInstanceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeregisterManagedInstance operation. ///

/// /// The IAsyncResult returned by the call to BeginDeregisterManagedInstance. /// /// Returns a DeregisterManagedInstanceResult from SimpleSystemsManagement. /// REST API Reference for DeregisterManagedInstance Operation public virtual DeregisterManagedInstanceResponse EndDeregisterManagedInstance(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeregisterPatchBaselineForPatchGroup ///

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

/// Container for the necessary parameters to execute the DeregisterPatchBaselineForPatchGroup service method. /// /// 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 DeregisterPatchBaselineForPatchGroupResponse DeregisterPatchBaselineForPatchGroup(DeregisterPatchBaselineForPatchGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterPatchBaselineForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterPatchBaselineForPatchGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeregisterPatchBaselineForPatchGroup operation. ///

/// /// Container for the necessary parameters to execute the DeregisterPatchBaselineForPatchGroup operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterPatchBaselineForPatchGroup /// operation. /// REST API Reference for DeregisterPatchBaselineForPatchGroup Operation public virtual IAsyncResult BeginDeregisterPatchBaselineForPatchGroup(DeregisterPatchBaselineForPatchGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterPatchBaselineForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterPatchBaselineForPatchGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeregisterPatchBaselineForPatchGroup operation. ///

/// /// The IAsyncResult returned by the call to BeginDeregisterPatchBaselineForPatchGroup. /// /// Returns a DeregisterPatchBaselineForPatchGroupResult from SimpleSystemsManagement. /// REST API Reference for DeregisterPatchBaselineForPatchGroup Operation public virtual DeregisterPatchBaselineForPatchGroupResponse EndDeregisterPatchBaselineForPatchGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeregisterTargetFromMaintenanceWindow ///

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

/// Container for the necessary parameters to execute the DeregisterTargetFromMaintenanceWindow service method. /// /// 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 DeregisterTargetFromMaintenanceWindowResponse DeregisterTargetFromMaintenanceWindow(DeregisterTargetFromMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterTargetFromMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterTargetFromMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeregisterTargetFromMaintenanceWindow operation. ///

/// /// Container for the necessary parameters to execute the DeregisterTargetFromMaintenanceWindow operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterTargetFromMaintenanceWindow /// operation. /// REST API Reference for DeregisterTargetFromMaintenanceWindow Operation public virtual IAsyncResult BeginDeregisterTargetFromMaintenanceWindow(DeregisterTargetFromMaintenanceWindowRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterTargetFromMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterTargetFromMaintenanceWindowResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeregisterTargetFromMaintenanceWindow operation. ///

/// /// The IAsyncResult returned by the call to BeginDeregisterTargetFromMaintenanceWindow. /// /// Returns a DeregisterTargetFromMaintenanceWindowResult from SimpleSystemsManagement. /// REST API Reference for DeregisterTargetFromMaintenanceWindow Operation public virtual DeregisterTargetFromMaintenanceWindowResponse EndDeregisterTargetFromMaintenanceWindow(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeregisterTaskFromMaintenanceWindow ///

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

/// Container for the necessary parameters to execute the DeregisterTaskFromMaintenanceWindow service method. /// /// 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 DeregisterTaskFromMaintenanceWindowResponse DeregisterTaskFromMaintenanceWindow(DeregisterTaskFromMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterTaskFromMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterTaskFromMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeregisterTaskFromMaintenanceWindow operation. ///

/// /// Container for the necessary parameters to execute the DeregisterTaskFromMaintenanceWindow operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterTaskFromMaintenanceWindow /// operation. /// REST API Reference for DeregisterTaskFromMaintenanceWindow Operation public virtual IAsyncResult BeginDeregisterTaskFromMaintenanceWindow(DeregisterTaskFromMaintenanceWindowRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterTaskFromMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterTaskFromMaintenanceWindowResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeregisterTaskFromMaintenanceWindow operation. ///

/// /// The IAsyncResult returned by the call to BeginDeregisterTaskFromMaintenanceWindow. /// /// Returns a DeregisterTaskFromMaintenanceWindowResult from SimpleSystemsManagement. /// REST API Reference for DeregisterTaskFromMaintenanceWindow Operation public virtual DeregisterTaskFromMaintenanceWindowResponse EndDeregisterTaskFromMaintenanceWindow(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeActivations ///

/// 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. /// /// 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 DescribeActivationsResponse DescribeActivations(DescribeActivationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeActivationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeActivationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeActivations operation. ///

/// /// Container for the necessary parameters to execute the DescribeActivations operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeActivations /// operation. /// REST API Reference for DescribeActivations Operation public virtual IAsyncResult BeginDescribeActivations(DescribeActivationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeActivationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeActivationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeActivations operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeActivations. /// /// Returns a DescribeActivationsResult from SimpleSystemsManagement. /// REST API Reference for DescribeActivations Operation public virtual DescribeActivationsResponse EndDescribeActivations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeAssociation ///

/// 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. /// /// 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 DescribeAssociationResponse DescribeAssociation(string instanceId, string name) { var request = new DescribeAssociationRequest(); request.InstanceId = instanceId; request.Name = name; return DescribeAssociation(request); } ///

/// Container for the necessary parameters to execute the DescribeAssociation service method. /// /// 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 DescribeAssociationResponse DescribeAssociation(DescribeAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeAssociation operation. ///

/// /// Container for the necessary parameters to execute the DescribeAssociation operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeAssociation /// operation. /// REST API Reference for DescribeAssociation Operation public virtual IAsyncResult BeginDescribeAssociation(DescribeAssociationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAssociationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeAssociation operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeAssociation. /// /// Returns a DescribeAssociationResult from SimpleSystemsManagement. /// REST API Reference for DescribeAssociation Operation public virtual DescribeAssociationResponse EndDescribeAssociation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeAssociationExecutions ///

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

/// Container for the necessary parameters to execute the DescribeAssociationExecutions service method. /// /// 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 DescribeAssociationExecutionsResponse DescribeAssociationExecutions(DescribeAssociationExecutionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAssociationExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAssociationExecutionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeAssociationExecutions operation. ///

/// /// Container for the necessary parameters to execute the DescribeAssociationExecutions operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeAssociationExecutions /// operation. /// REST API Reference for DescribeAssociationExecutions Operation public virtual IAsyncResult BeginDescribeAssociationExecutions(DescribeAssociationExecutionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAssociationExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAssociationExecutionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeAssociationExecutions operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeAssociationExecutions. /// /// Returns a DescribeAssociationExecutionsResult from SimpleSystemsManagement. /// REST API Reference for DescribeAssociationExecutions Operation public virtual DescribeAssociationExecutionsResponse EndDescribeAssociationExecutions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeAssociationExecutionTargets ///

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

/// Container for the necessary parameters to execute the DescribeAssociationExecutionTargets service method. /// /// 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 DescribeAssociationExecutionTargetsResponse DescribeAssociationExecutionTargets(DescribeAssociationExecutionTargetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAssociationExecutionTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAssociationExecutionTargetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeAssociationExecutionTargets operation. ///

/// /// Container for the necessary parameters to execute the DescribeAssociationExecutionTargets operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeAssociationExecutionTargets /// operation. /// REST API Reference for DescribeAssociationExecutionTargets Operation public virtual IAsyncResult BeginDescribeAssociationExecutionTargets(DescribeAssociationExecutionTargetsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAssociationExecutionTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAssociationExecutionTargetsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeAssociationExecutionTargets operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeAssociationExecutionTargets. /// /// Returns a DescribeAssociationExecutionTargetsResult from SimpleSystemsManagement. /// REST API Reference for DescribeAssociationExecutionTargets Operation public virtual DescribeAssociationExecutionTargetsResponse EndDescribeAssociationExecutionTargets(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeAutomationExecutions ///

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

/// Container for the necessary parameters to execute the DescribeAutomationExecutions service method. /// /// 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 DescribeAutomationExecutionsResponse DescribeAutomationExecutions(DescribeAutomationExecutionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAutomationExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAutomationExecutionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeAutomationExecutions operation. ///

/// /// Container for the necessary parameters to execute the DescribeAutomationExecutions operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeAutomationExecutions /// operation. /// REST API Reference for DescribeAutomationExecutions Operation public virtual IAsyncResult BeginDescribeAutomationExecutions(DescribeAutomationExecutionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAutomationExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAutomationExecutionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeAutomationExecutions operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeAutomationExecutions. /// /// Returns a DescribeAutomationExecutionsResult from SimpleSystemsManagement. /// REST API Reference for DescribeAutomationExecutions Operation public virtual DescribeAutomationExecutionsResponse EndDescribeAutomationExecutions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeAutomationStepExecutions ///

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

/// Container for the necessary parameters to execute the DescribeAutomationStepExecutions service method. /// /// 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 DescribeAutomationStepExecutionsResponse DescribeAutomationStepExecutions(DescribeAutomationStepExecutionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAutomationStepExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAutomationStepExecutionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeAutomationStepExecutions operation. ///

/// /// Container for the necessary parameters to execute the DescribeAutomationStepExecutions operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeAutomationStepExecutions /// operation. /// REST API Reference for DescribeAutomationStepExecutions Operation public virtual IAsyncResult BeginDescribeAutomationStepExecutions(DescribeAutomationStepExecutionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAutomationStepExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAutomationStepExecutionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeAutomationStepExecutions operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeAutomationStepExecutions. /// /// Returns a DescribeAutomationStepExecutionsResult from SimpleSystemsManagement. /// REST API Reference for DescribeAutomationStepExecutions Operation public virtual DescribeAutomationStepExecutionsResponse EndDescribeAutomationStepExecutions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeAvailablePatches ///

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

/// Container for the necessary parameters to execute the DescribeAvailablePatches service method. /// /// 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 DescribeAvailablePatchesResponse DescribeAvailablePatches(DescribeAvailablePatchesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAvailablePatchesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAvailablePatchesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeAvailablePatches operation. ///

/// /// Container for the necessary parameters to execute the DescribeAvailablePatches operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeAvailablePatches /// operation. /// REST API Reference for DescribeAvailablePatches Operation public virtual IAsyncResult BeginDescribeAvailablePatches(DescribeAvailablePatchesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeAvailablePatchesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeAvailablePatchesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeAvailablePatches operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeAvailablePatches. /// /// Returns a DescribeAvailablePatchesResult from SimpleSystemsManagement. /// REST API Reference for DescribeAvailablePatches Operation public virtual DescribeAvailablePatchesResponse EndDescribeAvailablePatches(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeDocument ///

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

/// The name of the SSM document. /// /// 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 DescribeDocumentResponse DescribeDocument(string name) { var request = new DescribeDocumentRequest(); request.Name = name; return DescribeDocument(request); } ///

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

/// Container for the necessary parameters to execute the DescribeDocument service method. /// /// 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 DescribeDocumentResponse DescribeDocument(DescribeDocumentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDocumentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeDocument operation. ///

/// /// Container for the necessary parameters to execute the DescribeDocument operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeDocument /// operation. /// REST API Reference for DescribeDocument Operation public virtual IAsyncResult BeginDescribeDocument(DescribeDocumentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDocumentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeDocument operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeDocument. /// /// Returns a DescribeDocumentResult from SimpleSystemsManagement. /// REST API Reference for DescribeDocument Operation public virtual DescribeDocumentResponse EndDescribeDocument(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeDocumentPermission ///

/// 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. /// /// 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 DescribeDocumentPermissionResponse DescribeDocumentPermission(DescribeDocumentPermissionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDocumentPermissionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDocumentPermissionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeDocumentPermission operation. ///

/// /// Container for the necessary parameters to execute the DescribeDocumentPermission operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeDocumentPermission /// operation. /// REST API Reference for DescribeDocumentPermission Operation public virtual IAsyncResult BeginDescribeDocumentPermission(DescribeDocumentPermissionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDocumentPermissionRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDocumentPermissionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeDocumentPermission operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeDocumentPermission. /// /// Returns a DescribeDocumentPermissionResult from SimpleSystemsManagement. /// REST API Reference for DescribeDocumentPermission Operation public virtual DescribeDocumentPermissionResponse EndDescribeDocumentPermission(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeEffectiveInstanceAssociations ///

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

/// Container for the necessary parameters to execute the DescribeEffectiveInstanceAssociations service method. /// /// 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 DescribeEffectiveInstanceAssociationsResponse DescribeEffectiveInstanceAssociations(DescribeEffectiveInstanceAssociationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEffectiveInstanceAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEffectiveInstanceAssociationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeEffectiveInstanceAssociations operation. ///

/// /// Container for the necessary parameters to execute the DescribeEffectiveInstanceAssociations operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeEffectiveInstanceAssociations /// operation. /// REST API Reference for DescribeEffectiveInstanceAssociations Operation public virtual IAsyncResult BeginDescribeEffectiveInstanceAssociations(DescribeEffectiveInstanceAssociationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEffectiveInstanceAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEffectiveInstanceAssociationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeEffectiveInstanceAssociations operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeEffectiveInstanceAssociations. /// /// Returns a DescribeEffectiveInstanceAssociationsResult from SimpleSystemsManagement. /// REST API Reference for DescribeEffectiveInstanceAssociations Operation public virtual DescribeEffectiveInstanceAssociationsResponse EndDescribeEffectiveInstanceAssociations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeEffectivePatchesForPatchBaseline ///

/// 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. /// /// 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 DescribeEffectivePatchesForPatchBaselineResponse DescribeEffectivePatchesForPatchBaseline(DescribeEffectivePatchesForPatchBaselineRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEffectivePatchesForPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEffectivePatchesForPatchBaselineResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeEffectivePatchesForPatchBaseline operation. ///

/// /// Container for the necessary parameters to execute the DescribeEffectivePatchesForPatchBaseline operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeEffectivePatchesForPatchBaseline /// operation. /// REST API Reference for DescribeEffectivePatchesForPatchBaseline Operation public virtual IAsyncResult BeginDescribeEffectivePatchesForPatchBaseline(DescribeEffectivePatchesForPatchBaselineRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEffectivePatchesForPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEffectivePatchesForPatchBaselineResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeEffectivePatchesForPatchBaseline operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeEffectivePatchesForPatchBaseline. /// /// Returns a DescribeEffectivePatchesForPatchBaselineResult from SimpleSystemsManagement. /// REST API Reference for DescribeEffectivePatchesForPatchBaseline Operation public virtual DescribeEffectivePatchesForPatchBaselineResponse EndDescribeEffectivePatchesForPatchBaseline(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeInstanceAssociationsStatus ///

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

/// Container for the necessary parameters to execute the DescribeInstanceAssociationsStatus service method. /// /// 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 DescribeInstanceAssociationsStatusResponse DescribeInstanceAssociationsStatus(DescribeInstanceAssociationsStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstanceAssociationsStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstanceAssociationsStatusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeInstanceAssociationsStatus operation. ///

/// /// Container for the necessary parameters to execute the DescribeInstanceAssociationsStatus operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstanceAssociationsStatus /// operation. /// REST API Reference for DescribeInstanceAssociationsStatus Operation public virtual IAsyncResult BeginDescribeInstanceAssociationsStatus(DescribeInstanceAssociationsStatusRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstanceAssociationsStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstanceAssociationsStatusResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeInstanceAssociationsStatus operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeInstanceAssociationsStatus. /// /// Returns a DescribeInstanceAssociationsStatusResult from SimpleSystemsManagement. /// REST API Reference for DescribeInstanceAssociationsStatus Operation public virtual DescribeInstanceAssociationsStatusResponse EndDescribeInstanceAssociationsStatus(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeInstanceInformation ///

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

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

/// Container for the necessary parameters to execute the DescribeInstanceInformation service method. /// /// 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 DescribeInstanceInformationResponse DescribeInstanceInformation(DescribeInstanceInformationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstanceInformationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstanceInformationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeInstanceInformation operation. ///

/// /// Container for the necessary parameters to execute the DescribeInstanceInformation operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstanceInformation /// operation. /// REST API Reference for DescribeInstanceInformation Operation public virtual IAsyncResult BeginDescribeInstanceInformation(DescribeInstanceInformationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstanceInformationRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstanceInformationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeInstanceInformation operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeInstanceInformation. /// /// Returns a DescribeInstanceInformationResult from SimpleSystemsManagement. /// REST API Reference for DescribeInstanceInformation Operation public virtual DescribeInstanceInformationResponse EndDescribeInstanceInformation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeInstancePatches ///

/// 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. /// /// 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 DescribeInstancePatchesResponse DescribeInstancePatches(DescribeInstancePatchesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstancePatchesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstancePatchesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeInstancePatches operation. ///

/// /// Container for the necessary parameters to execute the DescribeInstancePatches operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstancePatches /// operation. /// REST API Reference for DescribeInstancePatches Operation public virtual IAsyncResult BeginDescribeInstancePatches(DescribeInstancePatchesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstancePatchesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstancePatchesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeInstancePatches operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeInstancePatches. /// /// Returns a DescribeInstancePatchesResult from SimpleSystemsManagement. /// REST API Reference for DescribeInstancePatches Operation public virtual DescribeInstancePatchesResponse EndDescribeInstancePatches(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeInstancePatchStates ///

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

/// Container for the necessary parameters to execute the DescribeInstancePatchStates service method. /// /// 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 DescribeInstancePatchStatesResponse DescribeInstancePatchStates(DescribeInstancePatchStatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstancePatchStatesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstancePatchStatesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeInstancePatchStates operation. ///

/// /// Container for the necessary parameters to execute the DescribeInstancePatchStates operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstancePatchStates /// operation. /// REST API Reference for DescribeInstancePatchStates Operation public virtual IAsyncResult BeginDescribeInstancePatchStates(DescribeInstancePatchStatesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstancePatchStatesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstancePatchStatesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeInstancePatchStates operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeInstancePatchStates. /// /// Returns a DescribeInstancePatchStatesResult from SimpleSystemsManagement. /// REST API Reference for DescribeInstancePatchStates Operation public virtual DescribeInstancePatchStatesResponse EndDescribeInstancePatchStates(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeInstancePatchStatesForPatchGroup ///

/// 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. /// /// 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 DescribeInstancePatchStatesForPatchGroupResponse DescribeInstancePatchStatesForPatchGroup(DescribeInstancePatchStatesForPatchGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstancePatchStatesForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstancePatchStatesForPatchGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeInstancePatchStatesForPatchGroup operation. ///

/// /// Container for the necessary parameters to execute the DescribeInstancePatchStatesForPatchGroup operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstancePatchStatesForPatchGroup /// operation. /// REST API Reference for DescribeInstancePatchStatesForPatchGroup Operation public virtual IAsyncResult BeginDescribeInstancePatchStatesForPatchGroup(DescribeInstancePatchStatesForPatchGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInstancePatchStatesForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInstancePatchStatesForPatchGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeInstancePatchStatesForPatchGroup operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeInstancePatchStatesForPatchGroup. /// /// Returns a DescribeInstancePatchStatesForPatchGroupResult from SimpleSystemsManagement. /// REST API Reference for DescribeInstancePatchStatesForPatchGroup Operation public virtual DescribeInstancePatchStatesForPatchGroupResponse EndDescribeInstancePatchStatesForPatchGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeInventoryDeletions ///

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

/// Container for the necessary parameters to execute the DescribeInventoryDeletions service method. /// /// 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 DescribeInventoryDeletionsResponse DescribeInventoryDeletions(DescribeInventoryDeletionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInventoryDeletionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInventoryDeletionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeInventoryDeletions operation. ///

/// /// Container for the necessary parameters to execute the DescribeInventoryDeletions operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInventoryDeletions /// operation. /// REST API Reference for DescribeInventoryDeletions Operation public virtual IAsyncResult BeginDescribeInventoryDeletions(DescribeInventoryDeletionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeInventoryDeletionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeInventoryDeletionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeInventoryDeletions operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeInventoryDeletions. /// /// Returns a DescribeInventoryDeletionsResult from SimpleSystemsManagement. /// REST API Reference for DescribeInventoryDeletions Operation public virtual DescribeInventoryDeletionsResponse EndDescribeInventoryDeletions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeMaintenanceWindowExecutions ///

/// 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. /// /// 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 DescribeMaintenanceWindowExecutionsResponse DescribeMaintenanceWindowExecutions(DescribeMaintenanceWindowExecutionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowExecutionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeMaintenanceWindowExecutions operation. ///

/// /// Container for the necessary parameters to execute the DescribeMaintenanceWindowExecutions operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeMaintenanceWindowExecutions /// operation. /// REST API Reference for DescribeMaintenanceWindowExecutions Operation public virtual IAsyncResult BeginDescribeMaintenanceWindowExecutions(DescribeMaintenanceWindowExecutionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowExecutionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowExecutionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeMaintenanceWindowExecutions operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeMaintenanceWindowExecutions. /// /// Returns a DescribeMaintenanceWindowExecutionsResult from SimpleSystemsManagement. /// REST API Reference for DescribeMaintenanceWindowExecutions Operation public virtual DescribeMaintenanceWindowExecutionsResponse EndDescribeMaintenanceWindowExecutions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeMaintenanceWindowExecutionTaskInvocations ///

/// 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. /// /// 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 DescribeMaintenanceWindowExecutionTaskInvocationsResponse DescribeMaintenanceWindowExecutionTaskInvocations(DescribeMaintenanceWindowExecutionTaskInvocationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowExecutionTaskInvocationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowExecutionTaskInvocationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeMaintenanceWindowExecutionTaskInvocations operation. ///

/// /// Container for the necessary parameters to execute the DescribeMaintenanceWindowExecutionTaskInvocations operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeMaintenanceWindowExecutionTaskInvocations /// operation. /// REST API Reference for DescribeMaintenanceWindowExecutionTaskInvocations Operation public virtual IAsyncResult BeginDescribeMaintenanceWindowExecutionTaskInvocations(DescribeMaintenanceWindowExecutionTaskInvocationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowExecutionTaskInvocationsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowExecutionTaskInvocationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeMaintenanceWindowExecutionTaskInvocations operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeMaintenanceWindowExecutionTaskInvocations. /// /// Returns a DescribeMaintenanceWindowExecutionTaskInvocationsResult from SimpleSystemsManagement. /// REST API Reference for DescribeMaintenanceWindowExecutionTaskInvocations Operation public virtual DescribeMaintenanceWindowExecutionTaskInvocationsResponse EndDescribeMaintenanceWindowExecutionTaskInvocations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeMaintenanceWindowExecutionTasks ///

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

/// Container for the necessary parameters to execute the DescribeMaintenanceWindowExecutionTasks service method. /// /// 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 DescribeMaintenanceWindowExecutionTasksResponse DescribeMaintenanceWindowExecutionTasks(DescribeMaintenanceWindowExecutionTasksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowExecutionTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowExecutionTasksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeMaintenanceWindowExecutionTasks operation. ///

/// /// Container for the necessary parameters to execute the DescribeMaintenanceWindowExecutionTasks operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeMaintenanceWindowExecutionTasks /// operation. /// REST API Reference for DescribeMaintenanceWindowExecutionTasks Operation public virtual IAsyncResult BeginDescribeMaintenanceWindowExecutionTasks(DescribeMaintenanceWindowExecutionTasksRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowExecutionTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowExecutionTasksResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeMaintenanceWindowExecutionTasks operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeMaintenanceWindowExecutionTasks. /// /// Returns a DescribeMaintenanceWindowExecutionTasksResult from SimpleSystemsManagement. /// REST API Reference for DescribeMaintenanceWindowExecutionTasks Operation public virtual DescribeMaintenanceWindowExecutionTasksResponse EndDescribeMaintenanceWindowExecutionTasks(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeMaintenanceWindows ///

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

/// Container for the necessary parameters to execute the DescribeMaintenanceWindows service method. /// /// 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 DescribeMaintenanceWindowsResponse DescribeMaintenanceWindows(DescribeMaintenanceWindowsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeMaintenanceWindows operation. ///

/// /// Container for the necessary parameters to execute the DescribeMaintenanceWindows operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeMaintenanceWindows /// operation. /// REST API Reference for DescribeMaintenanceWindows Operation public virtual IAsyncResult BeginDescribeMaintenanceWindows(DescribeMaintenanceWindowsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeMaintenanceWindows operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeMaintenanceWindows. /// /// Returns a DescribeMaintenanceWindowsResult from SimpleSystemsManagement. /// REST API Reference for DescribeMaintenanceWindows Operation public virtual DescribeMaintenanceWindowsResponse EndDescribeMaintenanceWindows(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeMaintenanceWindowSchedule ///

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

/// Container for the necessary parameters to execute the DescribeMaintenanceWindowSchedule service method. /// /// 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 DescribeMaintenanceWindowScheduleResponse DescribeMaintenanceWindowSchedule(DescribeMaintenanceWindowScheduleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowScheduleRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowScheduleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeMaintenanceWindowSchedule operation. ///

/// /// Container for the necessary parameters to execute the DescribeMaintenanceWindowSchedule operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeMaintenanceWindowSchedule /// operation. /// REST API Reference for DescribeMaintenanceWindowSchedule Operation public virtual IAsyncResult BeginDescribeMaintenanceWindowSchedule(DescribeMaintenanceWindowScheduleRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowScheduleRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowScheduleResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeMaintenanceWindowSchedule operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeMaintenanceWindowSchedule. /// /// Returns a DescribeMaintenanceWindowScheduleResult from SimpleSystemsManagement. /// REST API Reference for DescribeMaintenanceWindowSchedule Operation public virtual DescribeMaintenanceWindowScheduleResponse EndDescribeMaintenanceWindowSchedule(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeMaintenanceWindowsForTarget ///

/// 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. /// /// 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 DescribeMaintenanceWindowsForTargetResponse DescribeMaintenanceWindowsForTarget(DescribeMaintenanceWindowsForTargetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowsForTargetRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowsForTargetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeMaintenanceWindowsForTarget operation. ///

/// /// Container for the necessary parameters to execute the DescribeMaintenanceWindowsForTarget operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeMaintenanceWindowsForTarget /// operation. /// REST API Reference for DescribeMaintenanceWindowsForTarget Operation public virtual IAsyncResult BeginDescribeMaintenanceWindowsForTarget(DescribeMaintenanceWindowsForTargetRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowsForTargetRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowsForTargetResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeMaintenanceWindowsForTarget operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeMaintenanceWindowsForTarget. /// /// Returns a DescribeMaintenanceWindowsForTargetResult from SimpleSystemsManagement. /// REST API Reference for DescribeMaintenanceWindowsForTarget Operation public virtual DescribeMaintenanceWindowsForTargetResponse EndDescribeMaintenanceWindowsForTarget(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeMaintenanceWindowTargets ///

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

/// Container for the necessary parameters to execute the DescribeMaintenanceWindowTargets service method. /// /// 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 DescribeMaintenanceWindowTargetsResponse DescribeMaintenanceWindowTargets(DescribeMaintenanceWindowTargetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowTargetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeMaintenanceWindowTargets operation. ///

/// /// Container for the necessary parameters to execute the DescribeMaintenanceWindowTargets operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeMaintenanceWindowTargets /// operation. /// REST API Reference for DescribeMaintenanceWindowTargets Operation public virtual IAsyncResult BeginDescribeMaintenanceWindowTargets(DescribeMaintenanceWindowTargetsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowTargetsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowTargetsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeMaintenanceWindowTargets operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeMaintenanceWindowTargets. /// /// Returns a DescribeMaintenanceWindowTargetsResult from SimpleSystemsManagement. /// REST API Reference for DescribeMaintenanceWindowTargets Operation public virtual DescribeMaintenanceWindowTargetsResponse EndDescribeMaintenanceWindowTargets(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeMaintenanceWindowTasks ///

/// 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. /// /// 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 DescribeMaintenanceWindowTasksResponse DescribeMaintenanceWindowTasks(DescribeMaintenanceWindowTasksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowTasksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeMaintenanceWindowTasks operation. ///

/// /// Container for the necessary parameters to execute the DescribeMaintenanceWindowTasks operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeMaintenanceWindowTasks /// operation. /// REST API Reference for DescribeMaintenanceWindowTasks Operation public virtual IAsyncResult BeginDescribeMaintenanceWindowTasks(DescribeMaintenanceWindowTasksRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeMaintenanceWindowTasksRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeMaintenanceWindowTasksResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeMaintenanceWindowTasks operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeMaintenanceWindowTasks. /// /// Returns a DescribeMaintenanceWindowTasksResult from SimpleSystemsManagement. /// REST API Reference for DescribeMaintenanceWindowTasks Operation public virtual DescribeMaintenanceWindowTasksResponse EndDescribeMaintenanceWindowTasks(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeOpsItems ///

/// 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. /// /// 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 DescribeOpsItemsResponse DescribeOpsItems(DescribeOpsItemsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeOpsItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeOpsItemsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeOpsItems operation. ///

/// /// Container for the necessary parameters to execute the DescribeOpsItems operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeOpsItems /// operation. /// REST API Reference for DescribeOpsItems Operation public virtual IAsyncResult BeginDescribeOpsItems(DescribeOpsItemsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeOpsItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeOpsItemsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeOpsItems operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeOpsItems. /// /// Returns a DescribeOpsItemsResult from SimpleSystemsManagement. /// REST API Reference for DescribeOpsItems Operation public virtual DescribeOpsItemsResponse EndDescribeOpsItems(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeParameters ///

/// 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. /// /// 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 DescribeParametersResponse DescribeParameters(DescribeParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeParameters operation. ///

/// /// Container for the necessary parameters to execute the DescribeParameters operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeParameters /// operation. /// REST API Reference for DescribeParameters Operation public virtual IAsyncResult BeginDescribeParameters(DescribeParametersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeParametersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeParameters operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeParameters. /// /// Returns a DescribeParametersResult from SimpleSystemsManagement. /// REST API Reference for DescribeParameters Operation public virtual DescribeParametersResponse EndDescribeParameters(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribePatchBaselines ///

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

/// Container for the necessary parameters to execute the DescribePatchBaselines service method. /// /// 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 DescribePatchBaselinesResponse DescribePatchBaselines(DescribePatchBaselinesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchBaselinesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchBaselinesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribePatchBaselines operation. ///

/// /// Container for the necessary parameters to execute the DescribePatchBaselines operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribePatchBaselines /// operation. /// REST API Reference for DescribePatchBaselines Operation public virtual IAsyncResult BeginDescribePatchBaselines(DescribePatchBaselinesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchBaselinesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchBaselinesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribePatchBaselines operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribePatchBaselines. /// /// Returns a DescribePatchBaselinesResult from SimpleSystemsManagement. /// REST API Reference for DescribePatchBaselines Operation public virtual DescribePatchBaselinesResponse EndDescribePatchBaselines(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribePatchGroups ///

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

/// Container for the necessary parameters to execute the DescribePatchGroups service method. /// /// 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 DescribePatchGroupsResponse DescribePatchGroups(DescribePatchGroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchGroupsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribePatchGroups operation. ///

/// /// Container for the necessary parameters to execute the DescribePatchGroups operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribePatchGroups /// operation. /// REST API Reference for DescribePatchGroups Operation public virtual IAsyncResult BeginDescribePatchGroups(DescribePatchGroupsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchGroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchGroupsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribePatchGroups operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribePatchGroups. /// /// Returns a DescribePatchGroupsResult from SimpleSystemsManagement. /// REST API Reference for DescribePatchGroups Operation public virtual DescribePatchGroupsResponse EndDescribePatchGroups(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribePatchGroupState ///

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

/// Container for the necessary parameters to execute the DescribePatchGroupState service method. /// /// 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 DescribePatchGroupStateResponse DescribePatchGroupState(DescribePatchGroupStateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchGroupStateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchGroupStateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribePatchGroupState operation. ///

/// /// Container for the necessary parameters to execute the DescribePatchGroupState operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribePatchGroupState /// operation. /// REST API Reference for DescribePatchGroupState Operation public virtual IAsyncResult BeginDescribePatchGroupState(DescribePatchGroupStateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchGroupStateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchGroupStateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribePatchGroupState operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribePatchGroupState. /// /// Returns a DescribePatchGroupStateResult from SimpleSystemsManagement. /// REST API Reference for DescribePatchGroupState Operation public virtual DescribePatchGroupStateResponse EndDescribePatchGroupState(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribePatchProperties ///

/// 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. /// /// 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 DescribePatchPropertiesResponse DescribePatchProperties(DescribePatchPropertiesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchPropertiesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchPropertiesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribePatchProperties operation. ///

/// /// Container for the necessary parameters to execute the DescribePatchProperties operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribePatchProperties /// operation. /// REST API Reference for DescribePatchProperties Operation public virtual IAsyncResult BeginDescribePatchProperties(DescribePatchPropertiesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribePatchPropertiesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribePatchPropertiesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribePatchProperties operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribePatchProperties. /// /// Returns a DescribePatchPropertiesResult from SimpleSystemsManagement. /// REST API Reference for DescribePatchProperties Operation public virtual DescribePatchPropertiesResponse EndDescribePatchProperties(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeSessions ///

/// 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. /// /// 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 DescribeSessionsResponse DescribeSessions(DescribeSessionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSessionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSessionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeSessions operation. ///

/// /// Container for the necessary parameters to execute the DescribeSessions operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSessions /// operation. /// REST API Reference for DescribeSessions Operation public virtual IAsyncResult BeginDescribeSessions(DescribeSessionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSessionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSessionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeSessions operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeSessions. /// /// Returns a DescribeSessionsResult from SimpleSystemsManagement. /// REST API Reference for DescribeSessions Operation public virtual DescribeSessionsResponse EndDescribeSessions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisassociateOpsItemRelatedItem ///

/// 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. /// /// 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 DisassociateOpsItemRelatedItemResponse DisassociateOpsItemRelatedItem(DisassociateOpsItemRelatedItemRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateOpsItemRelatedItemRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateOpsItemRelatedItemResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DisassociateOpsItemRelatedItem operation. ///

/// /// Container for the necessary parameters to execute the DisassociateOpsItemRelatedItem operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateOpsItemRelatedItem /// operation. /// REST API Reference for DisassociateOpsItemRelatedItem Operation public virtual IAsyncResult BeginDisassociateOpsItemRelatedItem(DisassociateOpsItemRelatedItemRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateOpsItemRelatedItemRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateOpsItemRelatedItemResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DisassociateOpsItemRelatedItem operation. ///

/// /// The IAsyncResult returned by the call to BeginDisassociateOpsItemRelatedItem. /// /// Returns a DisassociateOpsItemRelatedItemResult from SimpleSystemsManagement. /// REST API Reference for DisassociateOpsItemRelatedItem Operation public virtual DisassociateOpsItemRelatedItemResponse EndDisassociateOpsItemRelatedItem(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetAutomationExecution ///

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

/// Container for the necessary parameters to execute the GetAutomationExecution service method. /// /// 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 GetAutomationExecutionResponse GetAutomationExecution(GetAutomationExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetAutomationExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAutomationExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetAutomationExecution operation. ///

/// /// Container for the necessary parameters to execute the GetAutomationExecution operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetAutomationExecution /// operation. /// REST API Reference for GetAutomationExecution Operation public virtual IAsyncResult BeginGetAutomationExecution(GetAutomationExecutionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetAutomationExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAutomationExecutionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetAutomationExecution operation. ///

/// /// The IAsyncResult returned by the call to BeginGetAutomationExecution. /// /// Returns a GetAutomationExecutionResult from SimpleSystemsManagement. /// REST API Reference for GetAutomationExecution Operation public virtual GetAutomationExecutionResponse EndGetAutomationExecution(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetCalendarState ///

/// 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. /// /// 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 GetCalendarStateResponse GetCalendarState(GetCalendarStateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCalendarStateRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCalendarStateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetCalendarState operation. ///

/// /// Container for the necessary parameters to execute the GetCalendarState operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCalendarState /// operation. /// REST API Reference for GetCalendarState Operation public virtual IAsyncResult BeginGetCalendarState(GetCalendarStateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetCalendarStateRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCalendarStateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetCalendarState operation. ///

/// /// The IAsyncResult returned by the call to BeginGetCalendarState. /// /// Returns a GetCalendarStateResult from SimpleSystemsManagement. /// REST API Reference for GetCalendarState Operation public virtual GetCalendarStateResponse EndGetCalendarState(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetCommandInvocation ///

/// 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. /// /// 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 GetCommandInvocationResponse GetCommandInvocation(GetCommandInvocationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCommandInvocationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCommandInvocationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetCommandInvocation operation. ///

/// /// Container for the necessary parameters to execute the GetCommandInvocation operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCommandInvocation /// operation. /// REST API Reference for GetCommandInvocation Operation public virtual IAsyncResult BeginGetCommandInvocation(GetCommandInvocationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetCommandInvocationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCommandInvocationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetCommandInvocation operation. ///

/// /// The IAsyncResult returned by the call to BeginGetCommandInvocation. /// /// Returns a GetCommandInvocationResult from SimpleSystemsManagement. /// REST API Reference for GetCommandInvocation Operation public virtual GetCommandInvocationResponse EndGetCommandInvocation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetConnectionStatus ///

/// 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. /// /// 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 GetConnectionStatusResponse GetConnectionStatus(GetConnectionStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetConnectionStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConnectionStatusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetConnectionStatus operation. ///

/// /// Container for the necessary parameters to execute the GetConnectionStatus operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetConnectionStatus /// operation. /// REST API Reference for GetConnectionStatus Operation public virtual IAsyncResult BeginGetConnectionStatus(GetConnectionStatusRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetConnectionStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConnectionStatusResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetConnectionStatus operation. ///

/// /// The IAsyncResult returned by the call to BeginGetConnectionStatus. /// /// Returns a GetConnectionStatusResult from SimpleSystemsManagement. /// REST API Reference for GetConnectionStatus Operation public virtual GetConnectionStatusResponse EndGetConnectionStatus(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDefaultPatchBaseline ///

/// 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. /// /// 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 GetDefaultPatchBaselineResponse GetDefaultPatchBaseline(GetDefaultPatchBaselineRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDefaultPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDefaultPatchBaselineResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDefaultPatchBaseline operation. ///

/// /// Container for the necessary parameters to execute the GetDefaultPatchBaseline operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDefaultPatchBaseline /// operation. /// REST API Reference for GetDefaultPatchBaseline Operation public virtual IAsyncResult BeginGetDefaultPatchBaseline(GetDefaultPatchBaselineRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDefaultPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDefaultPatchBaselineResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDefaultPatchBaseline operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDefaultPatchBaseline. /// /// Returns a GetDefaultPatchBaselineResult from SimpleSystemsManagement. /// REST API Reference for GetDefaultPatchBaseline Operation public virtual GetDefaultPatchBaselineResponse EndGetDefaultPatchBaseline(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDeployablePatchSnapshotForInstance ///

/// 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. /// /// 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 GetDeployablePatchSnapshotForInstanceResponse GetDeployablePatchSnapshotForInstance(GetDeployablePatchSnapshotForInstanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDeployablePatchSnapshotForInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDeployablePatchSnapshotForInstanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDeployablePatchSnapshotForInstance operation. ///

/// /// Container for the necessary parameters to execute the GetDeployablePatchSnapshotForInstance operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDeployablePatchSnapshotForInstance /// operation. /// REST API Reference for GetDeployablePatchSnapshotForInstance Operation public virtual IAsyncResult BeginGetDeployablePatchSnapshotForInstance(GetDeployablePatchSnapshotForInstanceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDeployablePatchSnapshotForInstanceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDeployablePatchSnapshotForInstanceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDeployablePatchSnapshotForInstance operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDeployablePatchSnapshotForInstance. /// /// Returns a GetDeployablePatchSnapshotForInstanceResult from SimpleSystemsManagement. /// REST API Reference for GetDeployablePatchSnapshotForInstance Operation public virtual GetDeployablePatchSnapshotForInstanceResponse EndGetDeployablePatchSnapshotForInstance(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDocument ///

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

/// The name of the SSM document. /// /// 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 GetDocumentResponse GetDocument(string name) { var request = new GetDocumentRequest(); request.Name = name; return GetDocument(request); } ///

/// 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. /// /// 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 GetDocumentResponse GetDocument(GetDocumentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDocumentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDocument operation. ///

/// /// Container for the necessary parameters to execute the GetDocument operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDocument /// operation. /// REST API Reference for GetDocument Operation public virtual IAsyncResult BeginGetDocument(GetDocumentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDocumentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDocument operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDocument. /// /// Returns a GetDocumentResult from SimpleSystemsManagement. /// REST API Reference for GetDocument Operation public virtual GetDocumentResponse EndGetDocument(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetInventory ///

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

/// Container for the necessary parameters to execute the GetInventory service method. /// /// 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 GetInventoryResponse GetInventory(GetInventoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInventoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetInventory operation. ///

/// /// Container for the necessary parameters to execute the GetInventory operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetInventory /// operation. /// REST API Reference for GetInventory Operation public virtual IAsyncResult BeginGetInventory(GetInventoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInventoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetInventory operation. ///

/// /// The IAsyncResult returned by the call to BeginGetInventory. /// /// Returns a GetInventoryResult from SimpleSystemsManagement. /// REST API Reference for GetInventory Operation public virtual GetInventoryResponse EndGetInventory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetInventorySchema ///

/// 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. /// /// 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 GetInventorySchemaResponse GetInventorySchema(GetInventorySchemaRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetInventorySchemaRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInventorySchemaResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetInventorySchema operation. ///

/// /// Container for the necessary parameters to execute the GetInventorySchema operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetInventorySchema /// operation. /// REST API Reference for GetInventorySchema Operation public virtual IAsyncResult BeginGetInventorySchema(GetInventorySchemaRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetInventorySchemaRequestMarshaller.Instance; options.ResponseUnmarshaller = GetInventorySchemaResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetInventorySchema operation. ///

/// /// The IAsyncResult returned by the call to BeginGetInventorySchema. /// /// Returns a GetInventorySchemaResult from SimpleSystemsManagement. /// REST API Reference for GetInventorySchema Operation public virtual GetInventorySchemaResponse EndGetInventorySchema(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetMaintenanceWindow ///

/// Retrieves a maintenance window. ///

/// Container for the necessary parameters to execute the GetMaintenanceWindow service method. /// /// 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 GetMaintenanceWindowResponse GetMaintenanceWindow(GetMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetMaintenanceWindow operation. ///

/// /// Container for the necessary parameters to execute the GetMaintenanceWindow operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetMaintenanceWindow /// operation. /// REST API Reference for GetMaintenanceWindow Operation public virtual IAsyncResult BeginGetMaintenanceWindow(GetMaintenanceWindowRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetMaintenanceWindow operation. ///

/// /// The IAsyncResult returned by the call to BeginGetMaintenanceWindow. /// /// Returns a GetMaintenanceWindowResult from SimpleSystemsManagement. /// REST API Reference for GetMaintenanceWindow Operation public virtual GetMaintenanceWindowResponse EndGetMaintenanceWindow(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetMaintenanceWindowExecution ///

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

/// Container for the necessary parameters to execute the GetMaintenanceWindowExecution service method. /// /// 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 GetMaintenanceWindowExecutionResponse GetMaintenanceWindowExecution(GetMaintenanceWindowExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetMaintenanceWindowExecution operation. ///

/// /// Container for the necessary parameters to execute the GetMaintenanceWindowExecution operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetMaintenanceWindowExecution /// operation. /// REST API Reference for GetMaintenanceWindowExecution Operation public virtual IAsyncResult BeginGetMaintenanceWindowExecution(GetMaintenanceWindowExecutionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowExecutionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetMaintenanceWindowExecution operation. ///

/// /// The IAsyncResult returned by the call to BeginGetMaintenanceWindowExecution. /// /// Returns a GetMaintenanceWindowExecutionResult from SimpleSystemsManagement. /// REST API Reference for GetMaintenanceWindowExecution Operation public virtual GetMaintenanceWindowExecutionResponse EndGetMaintenanceWindowExecution(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetMaintenanceWindowExecutionTask ///

/// 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. /// /// 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 GetMaintenanceWindowExecutionTaskResponse GetMaintenanceWindowExecutionTask(GetMaintenanceWindowExecutionTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowExecutionTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowExecutionTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetMaintenanceWindowExecutionTask operation. ///

/// /// Container for the necessary parameters to execute the GetMaintenanceWindowExecutionTask operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetMaintenanceWindowExecutionTask /// operation. /// REST API Reference for GetMaintenanceWindowExecutionTask Operation public virtual IAsyncResult BeginGetMaintenanceWindowExecutionTask(GetMaintenanceWindowExecutionTaskRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowExecutionTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowExecutionTaskResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetMaintenanceWindowExecutionTask operation. ///

/// /// The IAsyncResult returned by the call to BeginGetMaintenanceWindowExecutionTask. /// /// Returns a GetMaintenanceWindowExecutionTaskResult from SimpleSystemsManagement. /// REST API Reference for GetMaintenanceWindowExecutionTask Operation public virtual GetMaintenanceWindowExecutionTaskResponse EndGetMaintenanceWindowExecutionTask(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetMaintenanceWindowExecutionTaskInvocation ///

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

/// Container for the necessary parameters to execute the GetMaintenanceWindowExecutionTaskInvocation service method. /// /// 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 GetMaintenanceWindowExecutionTaskInvocationResponse GetMaintenanceWindowExecutionTaskInvocation(GetMaintenanceWindowExecutionTaskInvocationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowExecutionTaskInvocationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowExecutionTaskInvocationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetMaintenanceWindowExecutionTaskInvocation operation. ///

/// /// Container for the necessary parameters to execute the GetMaintenanceWindowExecutionTaskInvocation operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetMaintenanceWindowExecutionTaskInvocation /// operation. /// REST API Reference for GetMaintenanceWindowExecutionTaskInvocation Operation public virtual IAsyncResult BeginGetMaintenanceWindowExecutionTaskInvocation(GetMaintenanceWindowExecutionTaskInvocationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowExecutionTaskInvocationRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowExecutionTaskInvocationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetMaintenanceWindowExecutionTaskInvocation operation. ///

/// /// The IAsyncResult returned by the call to BeginGetMaintenanceWindowExecutionTaskInvocation. /// /// Returns a GetMaintenanceWindowExecutionTaskInvocationResult from SimpleSystemsManagement. /// REST API Reference for GetMaintenanceWindowExecutionTaskInvocation Operation public virtual GetMaintenanceWindowExecutionTaskInvocationResponse EndGetMaintenanceWindowExecutionTaskInvocation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetMaintenanceWindowTask ///

/// 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. /// /// 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 GetMaintenanceWindowTaskResponse GetMaintenanceWindowTask(GetMaintenanceWindowTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetMaintenanceWindowTask operation. ///

/// /// Container for the necessary parameters to execute the GetMaintenanceWindowTask operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetMaintenanceWindowTask /// operation. /// REST API Reference for GetMaintenanceWindowTask Operation public virtual IAsyncResult BeginGetMaintenanceWindowTask(GetMaintenanceWindowTaskRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetMaintenanceWindowTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = GetMaintenanceWindowTaskResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetMaintenanceWindowTask operation. ///

/// /// The IAsyncResult returned by the call to BeginGetMaintenanceWindowTask. /// /// Returns a GetMaintenanceWindowTaskResult from SimpleSystemsManagement. /// REST API Reference for GetMaintenanceWindowTask Operation public virtual GetMaintenanceWindowTaskResponse EndGetMaintenanceWindowTask(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetOpsItem ///

/// 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. /// /// 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 GetOpsItemResponse GetOpsItem(GetOpsItemRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetOpsItemRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOpsItemResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetOpsItem operation. ///

/// /// Container for the necessary parameters to execute the GetOpsItem operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetOpsItem /// operation. /// REST API Reference for GetOpsItem Operation public virtual IAsyncResult BeginGetOpsItem(GetOpsItemRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetOpsItemRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOpsItemResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetOpsItem operation. ///

/// /// The IAsyncResult returned by the call to BeginGetOpsItem. /// /// Returns a GetOpsItemResult from SimpleSystemsManagement. /// REST API Reference for GetOpsItem Operation public virtual GetOpsItemResponse EndGetOpsItem(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetOpsMetadata ///

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

/// Container for the necessary parameters to execute the GetOpsMetadata service method. /// /// 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 GetOpsMetadataResponse GetOpsMetadata(GetOpsMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOpsMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetOpsMetadata operation. ///

/// /// Container for the necessary parameters to execute the GetOpsMetadata operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetOpsMetadata /// operation. /// REST API Reference for GetOpsMetadata Operation public virtual IAsyncResult BeginGetOpsMetadata(GetOpsMetadataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOpsMetadataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetOpsMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginGetOpsMetadata. /// /// Returns a GetOpsMetadataResult from SimpleSystemsManagement. /// REST API Reference for GetOpsMetadata Operation public virtual GetOpsMetadataResponse EndGetOpsMetadata(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetOpsSummary ///

/// 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. /// /// 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 GetOpsSummaryResponse GetOpsSummary(GetOpsSummaryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetOpsSummaryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOpsSummaryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetOpsSummary operation. ///

/// /// Container for the necessary parameters to execute the GetOpsSummary operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetOpsSummary /// operation. /// REST API Reference for GetOpsSummary Operation public virtual IAsyncResult BeginGetOpsSummary(GetOpsSummaryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetOpsSummaryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetOpsSummaryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetOpsSummary operation. ///

/// /// The IAsyncResult returned by the call to BeginGetOpsSummary. /// /// Returns a GetOpsSummaryResult from SimpleSystemsManagement. /// REST API Reference for GetOpsSummary Operation public virtual GetOpsSummaryResponse EndGetOpsSummary(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetParameter ///

/// 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. /// /// 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 GetParameterResponse GetParameter(GetParameterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetParameterRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParameterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetParameter operation. ///

/// /// Container for the necessary parameters to execute the GetParameter operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetParameter /// operation. /// REST API Reference for GetParameter Operation public virtual IAsyncResult BeginGetParameter(GetParameterRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetParameterRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParameterResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetParameter operation. ///

/// /// The IAsyncResult returned by the call to BeginGetParameter. /// /// Returns a GetParameterResult from SimpleSystemsManagement. /// REST API Reference for GetParameter Operation public virtual GetParameterResponse EndGetParameter(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetParameterHistory ///

/// 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. /// /// 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 GetParameterHistoryResponse GetParameterHistory(GetParameterHistoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetParameterHistoryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParameterHistoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetParameterHistory operation. ///

/// /// Container for the necessary parameters to execute the GetParameterHistory operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetParameterHistory /// operation. /// REST API Reference for GetParameterHistory Operation public virtual IAsyncResult BeginGetParameterHistory(GetParameterHistoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetParameterHistoryRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParameterHistoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetParameterHistory operation. ///

/// /// The IAsyncResult returned by the call to BeginGetParameterHistory. /// /// Returns a GetParameterHistoryResult from SimpleSystemsManagement. /// REST API Reference for GetParameterHistory Operation public virtual GetParameterHistoryResponse EndGetParameterHistory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetParameters ///

/// 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. /// /// 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 GetParametersResponse GetParameters(GetParametersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParametersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetParameters operation. ///

/// /// Container for the necessary parameters to execute the GetParameters operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetParameters /// operation. /// REST API Reference for GetParameters Operation public virtual IAsyncResult BeginGetParameters(GetParametersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetParametersRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParametersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetParameters operation. ///

/// /// The IAsyncResult returned by the call to BeginGetParameters. /// /// Returns a GetParametersResult from SimpleSystemsManagement. /// REST API Reference for GetParameters Operation public virtual GetParametersResponse EndGetParameters(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetParametersByPath ///

/// 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. /// /// 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 GetParametersByPathResponse GetParametersByPath(GetParametersByPathRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetParametersByPathRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParametersByPathResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetParametersByPath operation. ///

/// /// Container for the necessary parameters to execute the GetParametersByPath operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetParametersByPath /// operation. /// REST API Reference for GetParametersByPath Operation public virtual IAsyncResult BeginGetParametersByPath(GetParametersByPathRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetParametersByPathRequestMarshaller.Instance; options.ResponseUnmarshaller = GetParametersByPathResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetParametersByPath operation. ///

/// /// The IAsyncResult returned by the call to BeginGetParametersByPath. /// /// Returns a GetParametersByPathResult from SimpleSystemsManagement. /// REST API Reference for GetParametersByPath Operation public virtual GetParametersByPathResponse EndGetParametersByPath(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetPatchBaseline ///

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

/// Container for the necessary parameters to execute the GetPatchBaseline service method. /// /// 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 GetPatchBaselineResponse GetPatchBaseline(GetPatchBaselineRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = GetPatchBaselineResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetPatchBaseline operation. ///

/// /// Container for the necessary parameters to execute the GetPatchBaseline operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetPatchBaseline /// operation. /// REST API Reference for GetPatchBaseline Operation public virtual IAsyncResult BeginGetPatchBaseline(GetPatchBaselineRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = GetPatchBaselineResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetPatchBaseline operation. ///

/// /// The IAsyncResult returned by the call to BeginGetPatchBaseline. /// /// Returns a GetPatchBaselineResult from SimpleSystemsManagement. /// REST API Reference for GetPatchBaseline Operation public virtual GetPatchBaselineResponse EndGetPatchBaseline(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetPatchBaselineForPatchGroup ///

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

/// Container for the necessary parameters to execute the GetPatchBaselineForPatchGroup service method. /// /// 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 GetPatchBaselineForPatchGroupResponse GetPatchBaselineForPatchGroup(GetPatchBaselineForPatchGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetPatchBaselineForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = GetPatchBaselineForPatchGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetPatchBaselineForPatchGroup operation. ///

/// /// Container for the necessary parameters to execute the GetPatchBaselineForPatchGroup operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetPatchBaselineForPatchGroup /// operation. /// REST API Reference for GetPatchBaselineForPatchGroup Operation public virtual IAsyncResult BeginGetPatchBaselineForPatchGroup(GetPatchBaselineForPatchGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetPatchBaselineForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = GetPatchBaselineForPatchGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetPatchBaselineForPatchGroup operation. ///

/// /// The IAsyncResult returned by the call to BeginGetPatchBaselineForPatchGroup. /// /// Returns a GetPatchBaselineForPatchGroupResult from SimpleSystemsManagement. /// REST API Reference for GetPatchBaselineForPatchGroup Operation public virtual GetPatchBaselineForPatchGroupResponse EndGetPatchBaselineForPatchGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetResourcePolicies ///

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

/// Container for the necessary parameters to execute the GetResourcePolicies service method. /// /// 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 GetResourcePoliciesResponse GetResourcePolicies(GetResourcePoliciesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetResourcePoliciesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetResourcePoliciesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetResourcePolicies operation. ///

/// /// Container for the necessary parameters to execute the GetResourcePolicies operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetResourcePolicies /// operation. /// REST API Reference for GetResourcePolicies Operation public virtual IAsyncResult BeginGetResourcePolicies(GetResourcePoliciesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetResourcePoliciesRequestMarshaller.Instance; options.ResponseUnmarshaller = GetResourcePoliciesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetResourcePolicies operation. ///

/// /// The IAsyncResult returned by the call to BeginGetResourcePolicies. /// /// Returns a GetResourcePoliciesResult from SimpleSystemsManagement. /// REST API Reference for GetResourcePolicies Operation public virtual GetResourcePoliciesResponse EndGetResourcePolicies(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetServiceSetting ///

/// 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. /// /// 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 GetServiceSettingResponse GetServiceSetting(GetServiceSettingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceSettingRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceSettingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetServiceSetting operation. ///

/// /// Container for the necessary parameters to execute the GetServiceSetting operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetServiceSetting /// operation. /// REST API Reference for GetServiceSetting Operation public virtual IAsyncResult BeginGetServiceSetting(GetServiceSettingRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetServiceSettingRequestMarshaller.Instance; options.ResponseUnmarshaller = GetServiceSettingResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetServiceSetting operation. ///

/// /// The IAsyncResult returned by the call to BeginGetServiceSetting. /// /// Returns a GetServiceSettingResult from SimpleSystemsManagement. /// REST API Reference for GetServiceSetting Operation public virtual GetServiceSettingResponse EndGetServiceSetting(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region LabelParameterVersion ///

/// 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. /// /// 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 LabelParameterVersionResponse LabelParameterVersion(LabelParameterVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = LabelParameterVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = LabelParameterVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the LabelParameterVersion operation. ///

/// /// Container for the necessary parameters to execute the LabelParameterVersion operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndLabelParameterVersion /// operation. /// REST API Reference for LabelParameterVersion Operation public virtual IAsyncResult BeginLabelParameterVersion(LabelParameterVersionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = LabelParameterVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = LabelParameterVersionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the LabelParameterVersion operation. ///

/// /// The IAsyncResult returned by the call to BeginLabelParameterVersion. /// /// Returns a LabelParameterVersionResult from SimpleSystemsManagement. /// REST API Reference for LabelParameterVersion Operation public virtual LabelParameterVersionResponse EndLabelParameterVersion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListAssociations ///

/// 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. /// /// 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 ListAssociationsResponse ListAssociations(ListAssociationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAssociationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListAssociations operation. ///

/// /// Container for the necessary parameters to execute the ListAssociations operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListAssociations /// operation. /// REST API Reference for ListAssociations Operation public virtual IAsyncResult BeginListAssociations(ListAssociationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListAssociationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAssociationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListAssociations operation. ///

/// /// The IAsyncResult returned by the call to BeginListAssociations. /// /// Returns a ListAssociationsResult from SimpleSystemsManagement. /// REST API Reference for ListAssociations Operation public virtual ListAssociationsResponse EndListAssociations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListAssociationVersions ///

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

/// Container for the necessary parameters to execute the ListAssociationVersions service method. /// /// 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 ListAssociationVersionsResponse ListAssociationVersions(ListAssociationVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListAssociationVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAssociationVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListAssociationVersions operation. ///

/// /// Container for the necessary parameters to execute the ListAssociationVersions operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListAssociationVersions /// operation. /// REST API Reference for ListAssociationVersions Operation public virtual IAsyncResult BeginListAssociationVersions(ListAssociationVersionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListAssociationVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAssociationVersionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListAssociationVersions operation. ///

/// /// The IAsyncResult returned by the call to BeginListAssociationVersions. /// /// Returns a ListAssociationVersionsResult from SimpleSystemsManagement. /// REST API Reference for ListAssociationVersions Operation public virtual ListAssociationVersionsResponse EndListAssociationVersions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListCommandInvocations ///

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

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

/// (Optional) The invocations for a specific command ID. /// /// 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 ListCommandInvocationsResponse ListCommandInvocations(string commandId) { var request = new ListCommandInvocationsRequest(); request.CommandId = commandId; return ListCommandInvocations(request); } ///

/// Container for the necessary parameters to execute the ListCommandInvocations service method. /// /// 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 ListCommandInvocationsResponse ListCommandInvocations(ListCommandInvocationsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListCommandInvocationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCommandInvocationsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListCommandInvocations operation. ///

/// /// Container for the necessary parameters to execute the ListCommandInvocations operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListCommandInvocations /// operation. /// REST API Reference for ListCommandInvocations Operation public virtual IAsyncResult BeginListCommandInvocations(ListCommandInvocationsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListCommandInvocationsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCommandInvocationsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListCommandInvocations operation. ///

/// /// The IAsyncResult returned by the call to BeginListCommandInvocations. /// /// Returns a ListCommandInvocationsResult from SimpleSystemsManagement. /// REST API Reference for ListCommandInvocations Operation public virtual ListCommandInvocationsResponse EndListCommandInvocations(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListCommands ///

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

/// /// 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 ListCommandsResponse ListCommands() { return ListCommands(new ListCommandsRequest()); } ///

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

/// (Optional) If provided, lists only the specified command. /// /// 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 ListCommandsResponse ListCommands(string commandId) { var request = new ListCommandsRequest(); request.CommandId = commandId; return ListCommands(request); } ///

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

/// Container for the necessary parameters to execute the ListCommands service method. /// /// 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 ListCommandsResponse ListCommands(ListCommandsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListCommandsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCommandsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListCommands operation. ///

/// /// Container for the necessary parameters to execute the ListCommands operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListCommands /// operation. /// REST API Reference for ListCommands Operation public virtual IAsyncResult BeginListCommands(ListCommandsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListCommandsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCommandsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListCommands operation. ///

/// /// The IAsyncResult returned by the call to BeginListCommands. /// /// Returns a ListCommandsResult from SimpleSystemsManagement. /// REST API Reference for ListCommands Operation public virtual ListCommandsResponse EndListCommands(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListComplianceItems ///

/// 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. /// /// 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 ListComplianceItemsResponse ListComplianceItems(ListComplianceItemsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListComplianceItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListComplianceItemsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListComplianceItems operation. ///

/// /// Container for the necessary parameters to execute the ListComplianceItems operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListComplianceItems /// operation. /// REST API Reference for ListComplianceItems Operation public virtual IAsyncResult BeginListComplianceItems(ListComplianceItemsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListComplianceItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListComplianceItemsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListComplianceItems operation. ///

/// /// The IAsyncResult returned by the call to BeginListComplianceItems. /// /// Returns a ListComplianceItemsResult from SimpleSystemsManagement. /// REST API Reference for ListComplianceItems Operation public virtual ListComplianceItemsResponse EndListComplianceItems(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListComplianceSummaries ///

/// 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. /// /// 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 ListComplianceSummariesResponse ListComplianceSummaries(ListComplianceSummariesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListComplianceSummariesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListComplianceSummariesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListComplianceSummaries operation. ///

/// /// Container for the necessary parameters to execute the ListComplianceSummaries operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListComplianceSummaries /// operation. /// REST API Reference for ListComplianceSummaries Operation public virtual IAsyncResult BeginListComplianceSummaries(ListComplianceSummariesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListComplianceSummariesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListComplianceSummariesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListComplianceSummaries operation. ///

/// /// The IAsyncResult returned by the call to BeginListComplianceSummaries. /// /// Returns a ListComplianceSummariesResult from SimpleSystemsManagement. /// REST API Reference for ListComplianceSummaries Operation public virtual ListComplianceSummariesResponse EndListComplianceSummaries(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListDocumentMetadataHistory ///

/// 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. /// /// 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 ListDocumentMetadataHistoryResponse ListDocumentMetadataHistory(ListDocumentMetadataHistoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListDocumentMetadataHistoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDocumentMetadataHistoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListDocumentMetadataHistory operation. ///

/// /// Container for the necessary parameters to execute the ListDocumentMetadataHistory operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListDocumentMetadataHistory /// operation. /// REST API Reference for ListDocumentMetadataHistory Operation public virtual IAsyncResult BeginListDocumentMetadataHistory(ListDocumentMetadataHistoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListDocumentMetadataHistoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDocumentMetadataHistoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListDocumentMetadataHistory operation. ///

/// /// The IAsyncResult returned by the call to BeginListDocumentMetadataHistory. /// /// Returns a ListDocumentMetadataHistoryResult from SimpleSystemsManagement. /// REST API Reference for ListDocumentMetadataHistory Operation public virtual ListDocumentMetadataHistoryResponse EndListDocumentMetadataHistory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListDocuments ///

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

/// /// 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 ListDocumentsResponse ListDocuments() { return ListDocuments(new ListDocumentsRequest()); } ///

/// 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. /// /// 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 ListDocumentsResponse ListDocuments(ListDocumentsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListDocumentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDocumentsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListDocuments operation. ///

/// /// Container for the necessary parameters to execute the ListDocuments operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListDocuments /// operation. /// REST API Reference for ListDocuments Operation public virtual IAsyncResult BeginListDocuments(ListDocumentsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListDocumentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDocumentsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListDocuments operation. ///

/// /// The IAsyncResult returned by the call to BeginListDocuments. /// /// Returns a ListDocumentsResult from SimpleSystemsManagement. /// REST API Reference for ListDocuments Operation public virtual ListDocumentsResponse EndListDocuments(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListDocumentVersions ///

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

/// Container for the necessary parameters to execute the ListDocumentVersions service method. /// /// 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 ListDocumentVersionsResponse ListDocumentVersions(ListDocumentVersionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListDocumentVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDocumentVersionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListDocumentVersions operation. ///

/// /// Container for the necessary parameters to execute the ListDocumentVersions operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListDocumentVersions /// operation. /// REST API Reference for ListDocumentVersions Operation public virtual IAsyncResult BeginListDocumentVersions(ListDocumentVersionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListDocumentVersionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListDocumentVersionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListDocumentVersions operation. ///

/// /// The IAsyncResult returned by the call to BeginListDocumentVersions. /// /// Returns a ListDocumentVersionsResult from SimpleSystemsManagement. /// REST API Reference for ListDocumentVersions Operation public virtual ListDocumentVersionsResponse EndListDocumentVersions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListInventoryEntries ///

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

/// Container for the necessary parameters to execute the ListInventoryEntries service method. /// /// 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 ListInventoryEntriesResponse ListInventoryEntries(ListInventoryEntriesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListInventoryEntriesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListInventoryEntriesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListInventoryEntries operation. ///

/// /// Container for the necessary parameters to execute the ListInventoryEntries operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListInventoryEntries /// operation. /// REST API Reference for ListInventoryEntries Operation public virtual IAsyncResult BeginListInventoryEntries(ListInventoryEntriesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListInventoryEntriesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListInventoryEntriesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListInventoryEntries operation. ///

/// /// The IAsyncResult returned by the call to BeginListInventoryEntries. /// /// Returns a ListInventoryEntriesResult from SimpleSystemsManagement. /// REST API Reference for ListInventoryEntries Operation public virtual ListInventoryEntriesResponse EndListInventoryEntries(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListOpsItemEvents ///

/// 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. /// /// 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 ListOpsItemEventsResponse ListOpsItemEvents(ListOpsItemEventsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListOpsItemEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListOpsItemEventsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListOpsItemEvents operation. ///

/// /// Container for the necessary parameters to execute the ListOpsItemEvents operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListOpsItemEvents /// operation. /// REST API Reference for ListOpsItemEvents Operation public virtual IAsyncResult BeginListOpsItemEvents(ListOpsItemEventsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListOpsItemEventsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListOpsItemEventsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListOpsItemEvents operation. ///

/// /// The IAsyncResult returned by the call to BeginListOpsItemEvents. /// /// Returns a ListOpsItemEventsResult from SimpleSystemsManagement. /// REST API Reference for ListOpsItemEvents Operation public virtual ListOpsItemEventsResponse EndListOpsItemEvents(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListOpsItemRelatedItems ///

/// 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. /// /// 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 ListOpsItemRelatedItemsResponse ListOpsItemRelatedItems(ListOpsItemRelatedItemsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListOpsItemRelatedItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListOpsItemRelatedItemsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListOpsItemRelatedItems operation. ///

/// /// Container for the necessary parameters to execute the ListOpsItemRelatedItems operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListOpsItemRelatedItems /// operation. /// REST API Reference for ListOpsItemRelatedItems Operation public virtual IAsyncResult BeginListOpsItemRelatedItems(ListOpsItemRelatedItemsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListOpsItemRelatedItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListOpsItemRelatedItemsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListOpsItemRelatedItems operation. ///

/// /// The IAsyncResult returned by the call to BeginListOpsItemRelatedItems. /// /// Returns a ListOpsItemRelatedItemsResult from SimpleSystemsManagement. /// REST API Reference for ListOpsItemRelatedItems Operation public virtual ListOpsItemRelatedItemsResponse EndListOpsItemRelatedItems(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListOpsMetadata ///

/// 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. /// /// 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 ListOpsMetadataResponse ListOpsMetadata(ListOpsMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = ListOpsMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListOpsMetadata operation. ///

/// /// Container for the necessary parameters to execute the ListOpsMetadata operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListOpsMetadata /// operation. /// REST API Reference for ListOpsMetadata Operation public virtual IAsyncResult BeginListOpsMetadata(ListOpsMetadataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = ListOpsMetadataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListOpsMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginListOpsMetadata. /// /// Returns a ListOpsMetadataResult from SimpleSystemsManagement. /// REST API Reference for ListOpsMetadata Operation public virtual ListOpsMetadataResponse EndListOpsMetadata(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListResourceComplianceSummaries ///

/// 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. /// /// 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 ListResourceComplianceSummariesResponse ListResourceComplianceSummaries(ListResourceComplianceSummariesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListResourceComplianceSummariesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListResourceComplianceSummariesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListResourceComplianceSummaries operation. ///

/// /// Container for the necessary parameters to execute the ListResourceComplianceSummaries operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListResourceComplianceSummaries /// operation. /// REST API Reference for ListResourceComplianceSummaries Operation public virtual IAsyncResult BeginListResourceComplianceSummaries(ListResourceComplianceSummariesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListResourceComplianceSummariesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListResourceComplianceSummariesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListResourceComplianceSummaries operation. ///

/// /// The IAsyncResult returned by the call to BeginListResourceComplianceSummaries. /// /// Returns a ListResourceComplianceSummariesResult from SimpleSystemsManagement. /// REST API Reference for ListResourceComplianceSummaries Operation public virtual ListResourceComplianceSummariesResponse EndListResourceComplianceSummaries(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListResourceDataSync ///

/// 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. /// /// 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 ListResourceDataSyncResponse ListResourceDataSync(ListResourceDataSyncRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = ListResourceDataSyncResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListResourceDataSync operation. ///

/// /// Container for the necessary parameters to execute the ListResourceDataSync operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListResourceDataSync /// operation. /// REST API Reference for ListResourceDataSync Operation public virtual IAsyncResult BeginListResourceDataSync(ListResourceDataSyncRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = ListResourceDataSyncResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListResourceDataSync operation. ///

/// /// The IAsyncResult returned by the call to BeginListResourceDataSync. /// /// Returns a ListResourceDataSyncResult from SimpleSystemsManagement. /// REST API Reference for ListResourceDataSync Operation public virtual ListResourceDataSyncResponse EndListResourceDataSync(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTagsForResource ///

/// 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. /// /// 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 ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListTagsForResource operation. ///

/// /// Container for the necessary parameters to execute the ListTagsForResource operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTagsForResource /// operation. /// REST API Reference for ListTagsForResource Operation public virtual IAsyncResult BeginListTagsForResource(ListTagsForResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListTagsForResource operation. ///

/// /// The IAsyncResult returned by the call to BeginListTagsForResource. /// /// Returns a ListTagsForResourceResult from SimpleSystemsManagement. /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ModifyDocumentPermission ///

/// 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. /// /// 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 ModifyDocumentPermissionResponse ModifyDocumentPermission(ModifyDocumentPermissionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDocumentPermissionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDocumentPermissionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ModifyDocumentPermission operation. ///

/// /// Container for the necessary parameters to execute the ModifyDocumentPermission operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyDocumentPermission /// operation. /// REST API Reference for ModifyDocumentPermission Operation public virtual IAsyncResult BeginModifyDocumentPermission(ModifyDocumentPermissionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ModifyDocumentPermissionRequestMarshaller.Instance; options.ResponseUnmarshaller = ModifyDocumentPermissionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ModifyDocumentPermission operation. ///

/// /// The IAsyncResult returned by the call to BeginModifyDocumentPermission. /// /// Returns a ModifyDocumentPermissionResult from SimpleSystemsManagement. /// REST API Reference for ModifyDocumentPermission Operation public virtual ModifyDocumentPermissionResponse EndModifyDocumentPermission(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region PutComplianceItems ///

/// 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. /// /// 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 PutComplianceItemsResponse PutComplianceItems(PutComplianceItemsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutComplianceItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = PutComplianceItemsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the PutComplianceItems operation. ///

/// /// Container for the necessary parameters to execute the PutComplianceItems operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutComplianceItems /// operation. /// REST API Reference for PutComplianceItems Operation public virtual IAsyncResult BeginPutComplianceItems(PutComplianceItemsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = PutComplianceItemsRequestMarshaller.Instance; options.ResponseUnmarshaller = PutComplianceItemsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the PutComplianceItems operation. ///

/// /// The IAsyncResult returned by the call to BeginPutComplianceItems. /// /// Returns a PutComplianceItemsResult from SimpleSystemsManagement. /// REST API Reference for PutComplianceItems Operation public virtual PutComplianceItemsResponse EndPutComplianceItems(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region PutInventory ///

/// 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. /// /// 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 PutInventoryResponse PutInventory(PutInventoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = PutInventoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the PutInventory operation. ///

/// /// Container for the necessary parameters to execute the PutInventory operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutInventory /// operation. /// REST API Reference for PutInventory Operation public virtual IAsyncResult BeginPutInventory(PutInventoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = PutInventoryRequestMarshaller.Instance; options.ResponseUnmarshaller = PutInventoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the PutInventory operation. ///

/// /// The IAsyncResult returned by the call to BeginPutInventory. /// /// Returns a PutInventoryResult from SimpleSystemsManagement. /// REST API Reference for PutInventory Operation public virtual PutInventoryResponse EndPutInventory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region PutParameter ///

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

/// Container for the necessary parameters to execute the PutParameter service method. /// /// 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 PutParameterResponse PutParameter(PutParameterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutParameterRequestMarshaller.Instance; options.ResponseUnmarshaller = PutParameterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the PutParameter operation. ///

/// /// Container for the necessary parameters to execute the PutParameter operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutParameter /// operation. /// REST API Reference for PutParameter Operation public virtual IAsyncResult BeginPutParameter(PutParameterRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = PutParameterRequestMarshaller.Instance; options.ResponseUnmarshaller = PutParameterResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the PutParameter operation. ///

/// /// The IAsyncResult returned by the call to BeginPutParameter. /// /// Returns a PutParameterResult from SimpleSystemsManagement. /// REST API Reference for PutParameter Operation public virtual PutParameterResponse EndPutParameter(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region PutResourcePolicy ///

/// 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. /// /// 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 PutResourcePolicyResponse PutResourcePolicy(PutResourcePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutResourcePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the PutResourcePolicy operation. ///

/// /// Container for the necessary parameters to execute the PutResourcePolicy operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutResourcePolicy /// operation. /// REST API Reference for PutResourcePolicy Operation public virtual IAsyncResult BeginPutResourcePolicy(PutResourcePolicyRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = PutResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutResourcePolicyResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the PutResourcePolicy operation. ///

/// /// The IAsyncResult returned by the call to BeginPutResourcePolicy. /// /// Returns a PutResourcePolicyResult from SimpleSystemsManagement. /// REST API Reference for PutResourcePolicy Operation public virtual PutResourcePolicyResponse EndPutResourcePolicy(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RegisterDefaultPatchBaseline ///

/// 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. /// /// 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 RegisterDefaultPatchBaselineResponse RegisterDefaultPatchBaseline(RegisterDefaultPatchBaselineRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterDefaultPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterDefaultPatchBaselineResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RegisterDefaultPatchBaseline operation. ///

/// /// Container for the necessary parameters to execute the RegisterDefaultPatchBaseline operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterDefaultPatchBaseline /// operation. /// REST API Reference for RegisterDefaultPatchBaseline Operation public virtual IAsyncResult BeginRegisterDefaultPatchBaseline(RegisterDefaultPatchBaselineRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterDefaultPatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterDefaultPatchBaselineResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RegisterDefaultPatchBaseline operation. ///

/// /// The IAsyncResult returned by the call to BeginRegisterDefaultPatchBaseline. /// /// Returns a RegisterDefaultPatchBaselineResult from SimpleSystemsManagement. /// REST API Reference for RegisterDefaultPatchBaseline Operation public virtual RegisterDefaultPatchBaselineResponse EndRegisterDefaultPatchBaseline(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RegisterPatchBaselineForPatchGroup ///

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

/// Container for the necessary parameters to execute the RegisterPatchBaselineForPatchGroup service method. /// /// 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 RegisterPatchBaselineForPatchGroupResponse RegisterPatchBaselineForPatchGroup(RegisterPatchBaselineForPatchGroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterPatchBaselineForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterPatchBaselineForPatchGroupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RegisterPatchBaselineForPatchGroup operation. ///

/// /// Container for the necessary parameters to execute the RegisterPatchBaselineForPatchGroup operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterPatchBaselineForPatchGroup /// operation. /// REST API Reference for RegisterPatchBaselineForPatchGroup Operation public virtual IAsyncResult BeginRegisterPatchBaselineForPatchGroup(RegisterPatchBaselineForPatchGroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterPatchBaselineForPatchGroupRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterPatchBaselineForPatchGroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RegisterPatchBaselineForPatchGroup operation. ///

/// /// The IAsyncResult returned by the call to BeginRegisterPatchBaselineForPatchGroup. /// /// Returns a RegisterPatchBaselineForPatchGroupResult from SimpleSystemsManagement. /// REST API Reference for RegisterPatchBaselineForPatchGroup Operation public virtual RegisterPatchBaselineForPatchGroupResponse EndRegisterPatchBaselineForPatchGroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RegisterTargetWithMaintenanceWindow ///

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

/// Container for the necessary parameters to execute the RegisterTargetWithMaintenanceWindow service method. /// /// 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 RegisterTargetWithMaintenanceWindowResponse RegisterTargetWithMaintenanceWindow(RegisterTargetWithMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterTargetWithMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterTargetWithMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RegisterTargetWithMaintenanceWindow operation. ///

/// /// Container for the necessary parameters to execute the RegisterTargetWithMaintenanceWindow operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterTargetWithMaintenanceWindow /// operation. /// REST API Reference for RegisterTargetWithMaintenanceWindow Operation public virtual IAsyncResult BeginRegisterTargetWithMaintenanceWindow(RegisterTargetWithMaintenanceWindowRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterTargetWithMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterTargetWithMaintenanceWindowResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RegisterTargetWithMaintenanceWindow operation. ///

/// /// The IAsyncResult returned by the call to BeginRegisterTargetWithMaintenanceWindow. /// /// Returns a RegisterTargetWithMaintenanceWindowResult from SimpleSystemsManagement. /// REST API Reference for RegisterTargetWithMaintenanceWindow Operation public virtual RegisterTargetWithMaintenanceWindowResponse EndRegisterTargetWithMaintenanceWindow(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RegisterTaskWithMaintenanceWindow ///

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

/// Container for the necessary parameters to execute the RegisterTaskWithMaintenanceWindow service method. /// /// 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 RegisterTaskWithMaintenanceWindowResponse RegisterTaskWithMaintenanceWindow(RegisterTaskWithMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterTaskWithMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterTaskWithMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RegisterTaskWithMaintenanceWindow operation. ///

/// /// Container for the necessary parameters to execute the RegisterTaskWithMaintenanceWindow operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterTaskWithMaintenanceWindow /// operation. /// REST API Reference for RegisterTaskWithMaintenanceWindow Operation public virtual IAsyncResult BeginRegisterTaskWithMaintenanceWindow(RegisterTaskWithMaintenanceWindowRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterTaskWithMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterTaskWithMaintenanceWindowResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RegisterTaskWithMaintenanceWindow operation. ///

/// /// The IAsyncResult returned by the call to BeginRegisterTaskWithMaintenanceWindow. /// /// Returns a RegisterTaskWithMaintenanceWindowResult from SimpleSystemsManagement. /// REST API Reference for RegisterTaskWithMaintenanceWindow Operation public virtual RegisterTaskWithMaintenanceWindowResponse EndRegisterTaskWithMaintenanceWindow(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RemoveTagsFromResource ///

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

/// Container for the necessary parameters to execute the RemoveTagsFromResource service method. /// /// 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 RemoveTagsFromResourceResponse RemoveTagsFromResource(RemoveTagsFromResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveTagsFromResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveTagsFromResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RemoveTagsFromResource operation. ///

/// /// Container for the necessary parameters to execute the RemoveTagsFromResource operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRemoveTagsFromResource /// operation. /// REST API Reference for RemoveTagsFromResource Operation public virtual IAsyncResult BeginRemoveTagsFromResource(RemoveTagsFromResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveTagsFromResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveTagsFromResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RemoveTagsFromResource operation. ///

/// /// The IAsyncResult returned by the call to BeginRemoveTagsFromResource. /// /// Returns a RemoveTagsFromResourceResult from SimpleSystemsManagement. /// REST API Reference for RemoveTagsFromResource Operation public virtual RemoveTagsFromResourceResponse EndRemoveTagsFromResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ResetServiceSetting ///

/// 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. /// /// 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 ResetServiceSettingResponse ResetServiceSetting(ResetServiceSettingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ResetServiceSettingRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetServiceSettingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ResetServiceSetting operation. ///

/// /// Container for the necessary parameters to execute the ResetServiceSetting operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndResetServiceSetting /// operation. /// REST API Reference for ResetServiceSetting Operation public virtual IAsyncResult BeginResetServiceSetting(ResetServiceSettingRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ResetServiceSettingRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetServiceSettingResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ResetServiceSetting operation. ///

/// /// The IAsyncResult returned by the call to BeginResetServiceSetting. /// /// Returns a ResetServiceSettingResult from SimpleSystemsManagement. /// REST API Reference for ResetServiceSetting Operation public virtual ResetServiceSettingResponse EndResetServiceSetting(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ResumeSession ///

/// 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. /// /// 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 ResumeSessionResponse ResumeSession(ResumeSessionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ResumeSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = ResumeSessionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ResumeSession operation. ///

/// /// Container for the necessary parameters to execute the ResumeSession operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndResumeSession /// operation. /// REST API Reference for ResumeSession Operation public virtual IAsyncResult BeginResumeSession(ResumeSessionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ResumeSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = ResumeSessionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ResumeSession operation. ///

/// /// The IAsyncResult returned by the call to BeginResumeSession. /// /// Returns a ResumeSessionResult from SimpleSystemsManagement. /// REST API Reference for ResumeSession Operation public virtual ResumeSessionResponse EndResumeSession(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region SendAutomationSignal ///

/// 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. /// /// 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 SendAutomationSignalResponse SendAutomationSignal(SendAutomationSignalRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SendAutomationSignalRequestMarshaller.Instance; options.ResponseUnmarshaller = SendAutomationSignalResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the SendAutomationSignal operation. ///

/// /// Container for the necessary parameters to execute the SendAutomationSignal operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSendAutomationSignal /// operation. /// REST API Reference for SendAutomationSignal Operation public virtual IAsyncResult BeginSendAutomationSignal(SendAutomationSignalRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = SendAutomationSignalRequestMarshaller.Instance; options.ResponseUnmarshaller = SendAutomationSignalResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the SendAutomationSignal operation. ///

/// /// The IAsyncResult returned by the call to BeginSendAutomationSignal. /// /// Returns a SendAutomationSignalResult from SimpleSystemsManagement. /// REST API Reference for SendAutomationSignal Operation public virtual SendAutomationSignalResponse EndSendAutomationSignal(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region SendCommand ///

/// 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. /// /// 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 SendCommandResponse SendCommand(string documentName, List instanceIds) { var request = new SendCommandRequest(); request.DocumentName = documentName; request.InstanceIds = instanceIds; return SendCommand(request); } ///

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

/// Container for the necessary parameters to execute the SendCommand service method. /// /// 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 SendCommandResponse SendCommand(SendCommandRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SendCommandRequestMarshaller.Instance; options.ResponseUnmarshaller = SendCommandResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the SendCommand operation. ///

/// /// Container for the necessary parameters to execute the SendCommand operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSendCommand /// operation. /// REST API Reference for SendCommand Operation public virtual IAsyncResult BeginSendCommand(SendCommandRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = SendCommandRequestMarshaller.Instance; options.ResponseUnmarshaller = SendCommandResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the SendCommand operation. ///

/// /// The IAsyncResult returned by the call to BeginSendCommand. /// /// Returns a SendCommandResult from SimpleSystemsManagement. /// REST API Reference for SendCommand Operation public virtual SendCommandResponse EndSendCommand(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartAssociationsOnce ///

/// 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. /// /// 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 StartAssociationsOnceResponse StartAssociationsOnce(StartAssociationsOnceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartAssociationsOnceRequestMarshaller.Instance; options.ResponseUnmarshaller = StartAssociationsOnceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartAssociationsOnce operation. ///

/// /// Container for the necessary parameters to execute the StartAssociationsOnce operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartAssociationsOnce /// operation. /// REST API Reference for StartAssociationsOnce Operation public virtual IAsyncResult BeginStartAssociationsOnce(StartAssociationsOnceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartAssociationsOnceRequestMarshaller.Instance; options.ResponseUnmarshaller = StartAssociationsOnceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartAssociationsOnce operation. ///

/// /// The IAsyncResult returned by the call to BeginStartAssociationsOnce. /// /// Returns a StartAssociationsOnceResult from SimpleSystemsManagement. /// REST API Reference for StartAssociationsOnce Operation public virtual StartAssociationsOnceResponse EndStartAssociationsOnce(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartAutomationExecution ///

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

/// Container for the necessary parameters to execute the StartAutomationExecution service method. /// /// 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 StartAutomationExecutionResponse StartAutomationExecution(StartAutomationExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartAutomationExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartAutomationExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartAutomationExecution operation. ///

/// /// Container for the necessary parameters to execute the StartAutomationExecution operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartAutomationExecution /// operation. /// REST API Reference for StartAutomationExecution Operation public virtual IAsyncResult BeginStartAutomationExecution(StartAutomationExecutionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartAutomationExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartAutomationExecutionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartAutomationExecution operation. ///

/// /// The IAsyncResult returned by the call to BeginStartAutomationExecution. /// /// Returns a StartAutomationExecutionResult from SimpleSystemsManagement. /// REST API Reference for StartAutomationExecution Operation public virtual StartAutomationExecutionResponse EndStartAutomationExecution(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartChangeRequestExecution ///

/// 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. /// /// 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 StartChangeRequestExecutionResponse StartChangeRequestExecution(StartChangeRequestExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartChangeRequestExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartChangeRequestExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartChangeRequestExecution operation. ///

/// /// Container for the necessary parameters to execute the StartChangeRequestExecution operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartChangeRequestExecution /// operation. /// REST API Reference for StartChangeRequestExecution Operation public virtual IAsyncResult BeginStartChangeRequestExecution(StartChangeRequestExecutionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartChangeRequestExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartChangeRequestExecutionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartChangeRequestExecution operation. ///

/// /// The IAsyncResult returned by the call to BeginStartChangeRequestExecution. /// /// Returns a StartChangeRequestExecutionResult from SimpleSystemsManagement. /// REST API Reference for StartChangeRequestExecution Operation public virtual StartChangeRequestExecutionResponse EndStartChangeRequestExecution(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartSession ///

/// 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. /// /// 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 StartSessionResponse StartSession(StartSessionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartSessionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartSession operation. ///

/// /// Container for the necessary parameters to execute the StartSession operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartSession /// operation. /// REST API Reference for StartSession Operation public virtual IAsyncResult BeginStartSession(StartSessionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartSessionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartSession operation. ///

/// /// The IAsyncResult returned by the call to BeginStartSession. /// /// Returns a StartSessionResult from SimpleSystemsManagement. /// REST API Reference for StartSession Operation public virtual StartSessionResponse EndStartSession(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StopAutomationExecution ///

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

/// Container for the necessary parameters to execute the StopAutomationExecution service method. /// /// 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 StopAutomationExecutionResponse StopAutomationExecution(StopAutomationExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StopAutomationExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StopAutomationExecutionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StopAutomationExecution operation. ///

/// /// Container for the necessary parameters to execute the StopAutomationExecution operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStopAutomationExecution /// operation. /// REST API Reference for StopAutomationExecution Operation public virtual IAsyncResult BeginStopAutomationExecution(StopAutomationExecutionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StopAutomationExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StopAutomationExecutionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StopAutomationExecution operation. ///

/// /// The IAsyncResult returned by the call to BeginStopAutomationExecution. /// /// Returns a StopAutomationExecutionResult from SimpleSystemsManagement. /// REST API Reference for StopAutomationExecution Operation public virtual StopAutomationExecutionResponse EndStopAutomationExecution(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TerminateSession ///

/// 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. /// /// 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 TerminateSessionResponse TerminateSession(TerminateSessionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TerminateSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = TerminateSessionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the TerminateSession operation. ///

/// /// Container for the necessary parameters to execute the TerminateSession operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTerminateSession /// operation. /// REST API Reference for TerminateSession Operation public virtual IAsyncResult BeginTerminateSession(TerminateSessionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = TerminateSessionRequestMarshaller.Instance; options.ResponseUnmarshaller = TerminateSessionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the TerminateSession operation. ///

/// /// The IAsyncResult returned by the call to BeginTerminateSession. /// /// Returns a TerminateSessionResult from SimpleSystemsManagement. /// REST API Reference for TerminateSession Operation public virtual TerminateSessionResponse EndTerminateSession(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UnlabelParameterVersion ///

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

/// Container for the necessary parameters to execute the UnlabelParameterVersion service method. /// /// 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 UnlabelParameterVersionResponse UnlabelParameterVersion(UnlabelParameterVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UnlabelParameterVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = UnlabelParameterVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UnlabelParameterVersion operation. ///

/// /// Container for the necessary parameters to execute the UnlabelParameterVersion operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUnlabelParameterVersion /// operation. /// REST API Reference for UnlabelParameterVersion Operation public virtual IAsyncResult BeginUnlabelParameterVersion(UnlabelParameterVersionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UnlabelParameterVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = UnlabelParameterVersionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UnlabelParameterVersion operation. ///

/// /// The IAsyncResult returned by the call to BeginUnlabelParameterVersion. /// /// Returns a UnlabelParameterVersionResult from SimpleSystemsManagement. /// REST API Reference for UnlabelParameterVersion Operation public virtual UnlabelParameterVersionResponse EndUnlabelParameterVersion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateAssociation ///

/// 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. /// /// 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 UpdateAssociationResponse UpdateAssociation(UpdateAssociationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAssociationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateAssociation operation. ///

/// /// Container for the necessary parameters to execute the UpdateAssociation operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateAssociation /// operation. /// REST API Reference for UpdateAssociation Operation public virtual IAsyncResult BeginUpdateAssociation(UpdateAssociationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAssociationRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAssociationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateAssociation operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateAssociation. /// /// Returns a UpdateAssociationResult from SimpleSystemsManagement. /// REST API Reference for UpdateAssociation Operation public virtual UpdateAssociationResponse EndUpdateAssociation(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateAssociationStatus ///

/// 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. /// /// 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 UpdateAssociationStatusResponse UpdateAssociationStatus(UpdateAssociationStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAssociationStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAssociationStatusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateAssociationStatus operation. ///

/// /// Container for the necessary parameters to execute the UpdateAssociationStatus operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateAssociationStatus /// operation. /// REST API Reference for UpdateAssociationStatus Operation public virtual IAsyncResult BeginUpdateAssociationStatus(UpdateAssociationStatusRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateAssociationStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateAssociationStatusResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateAssociationStatus operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateAssociationStatus. /// /// Returns a UpdateAssociationStatusResult from SimpleSystemsManagement. /// REST API Reference for UpdateAssociationStatus Operation public virtual UpdateAssociationStatusResponse EndUpdateAssociationStatus(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateDocument ///

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

/// Container for the necessary parameters to execute the UpdateDocument service method. /// /// 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 UpdateDocumentResponse UpdateDocument(UpdateDocumentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDocumentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateDocument operation. ///

/// /// Container for the necessary parameters to execute the UpdateDocument operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateDocument /// operation. /// REST API Reference for UpdateDocument Operation public virtual IAsyncResult BeginUpdateDocument(UpdateDocumentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDocumentRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDocumentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateDocument operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateDocument. /// /// Returns a UpdateDocumentResult from SimpleSystemsManagement. /// REST API Reference for UpdateDocument Operation public virtual UpdateDocumentResponse EndUpdateDocument(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateDocumentDefaultVersion ///

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

/// Container for the necessary parameters to execute the UpdateDocumentDefaultVersion service method. /// /// The response from the UpdateDocumentDefaultVersion service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// The specified SSM document doesn't exist. /// /// /// The version of the document schema isn't supported. /// /// /// The document version isn't valid or doesn't exist. /// /// REST API Reference for UpdateDocumentDefaultVersion Operation public virtual UpdateDocumentDefaultVersionResponse UpdateDocumentDefaultVersion(UpdateDocumentDefaultVersionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDocumentDefaultVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDocumentDefaultVersionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateDocumentDefaultVersion operation. ///

/// /// Container for the necessary parameters to execute the UpdateDocumentDefaultVersion operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateDocumentDefaultVersion /// operation. /// REST API Reference for UpdateDocumentDefaultVersion Operation public virtual IAsyncResult BeginUpdateDocumentDefaultVersion(UpdateDocumentDefaultVersionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDocumentDefaultVersionRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDocumentDefaultVersionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateDocumentDefaultVersion operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateDocumentDefaultVersion. /// /// Returns a UpdateDocumentDefaultVersionResult from SimpleSystemsManagement. /// REST API Reference for UpdateDocumentDefaultVersion Operation public virtual UpdateDocumentDefaultVersionResponse EndUpdateDocumentDefaultVersion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateDocumentMetadata ///

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

/// Container for the necessary parameters to execute the UpdateDocumentMetadata service method. /// /// The response from the UpdateDocumentMetadata 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 document version isn't valid or doesn't exist. /// /// REST API Reference for UpdateDocumentMetadata Operation public virtual UpdateDocumentMetadataResponse UpdateDocumentMetadata(UpdateDocumentMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDocumentMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDocumentMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateDocumentMetadata operation. ///

/// /// Container for the necessary parameters to execute the UpdateDocumentMetadata operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateDocumentMetadata /// operation. /// REST API Reference for UpdateDocumentMetadata Operation public virtual IAsyncResult BeginUpdateDocumentMetadata(UpdateDocumentMetadataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDocumentMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDocumentMetadataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateDocumentMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateDocumentMetadata. /// /// Returns a UpdateDocumentMetadataResult from SimpleSystemsManagement. /// REST API Reference for UpdateDocumentMetadata Operation public virtual UpdateDocumentMetadataResponse EndUpdateDocumentMetadata(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateMaintenanceWindow ///

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

/// Container for the necessary parameters to execute the UpdateMaintenanceWindow service method. /// /// The response from the UpdateMaintenanceWindow 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 UpdateMaintenanceWindow Operation public virtual UpdateMaintenanceWindowResponse UpdateMaintenanceWindow(UpdateMaintenanceWindowRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateMaintenanceWindowResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateMaintenanceWindow operation. ///

/// /// Container for the necessary parameters to execute the UpdateMaintenanceWindow operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateMaintenanceWindow /// operation. /// REST API Reference for UpdateMaintenanceWindow Operation public virtual IAsyncResult BeginUpdateMaintenanceWindow(UpdateMaintenanceWindowRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateMaintenanceWindowRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateMaintenanceWindowResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateMaintenanceWindow operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateMaintenanceWindow. /// /// Returns a UpdateMaintenanceWindowResult from SimpleSystemsManagement. /// REST API Reference for UpdateMaintenanceWindow Operation public virtual UpdateMaintenanceWindowResponse EndUpdateMaintenanceWindow(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateMaintenanceWindowTarget ///

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

/// /// Name /// ///
/// /// Description /// ///
/// /// Owner /// ///
/// /// IDs for an ID target /// ///
/// /// Tags for a Tag target /// ///
/// /// From any supported tag type to another. The three supported tag types are ID target, /// Tag target, and resource group. For more information, see Target. /// ///

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

/// Container for the necessary parameters to execute the UpdateMaintenanceWindowTarget service method. /// /// The response from the UpdateMaintenanceWindowTarget 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 UpdateMaintenanceWindowTarget Operation public virtual UpdateMaintenanceWindowTargetResponse UpdateMaintenanceWindowTarget(UpdateMaintenanceWindowTargetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateMaintenanceWindowTargetRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateMaintenanceWindowTargetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateMaintenanceWindowTarget operation. ///

/// /// Container for the necessary parameters to execute the UpdateMaintenanceWindowTarget operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateMaintenanceWindowTarget /// operation. /// REST API Reference for UpdateMaintenanceWindowTarget Operation public virtual IAsyncResult BeginUpdateMaintenanceWindowTarget(UpdateMaintenanceWindowTargetRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateMaintenanceWindowTargetRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateMaintenanceWindowTargetResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateMaintenanceWindowTarget operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateMaintenanceWindowTarget. /// /// Returns a UpdateMaintenanceWindowTargetResult from SimpleSystemsManagement. /// REST API Reference for UpdateMaintenanceWindowTarget Operation public virtual UpdateMaintenanceWindowTargetResponse EndUpdateMaintenanceWindowTarget(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateMaintenanceWindowTask ///

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

/// /// TaskARN. For example, you can change a RUN_COMMAND task /// from AWS-RunPowerShellScript to AWS-RunShellScript. /// ///
/// /// ServiceRoleArn /// ///
/// /// TaskInvocationParameters /// ///
/// /// Priority /// ///
/// /// MaxConcurrency /// ///
/// /// MaxErrors /// ///

/// /// One or more targets must be specified for maintenance window Run Command-type tasks. /// Depending on the task, targets are optional for other maintenance window task types /// (Automation, Lambda, and Step Functions). For more information about running tasks /// that don't specify targets, see Registering /// maintenance window tasks without targets in the Amazon Web Services Systems /// Manager User Guide. /// /// /// /// If the value for a parameter in UpdateMaintenanceWindowTask is null, /// then the corresponding field isn't modified. If you set Replace to true, /// then all fields required by the RegisterTaskWithMaintenanceWindow operation /// are required for this request. Optional fields that aren't specified are set to null. /// /// /// /// When you update a maintenance window task that has options specified in TaskInvocationParameters, /// you must provide again all the TaskInvocationParameters values that you /// want to retain. The values you don't specify again are removed. For example, suppose /// that when you registered a Run Command task, you specified TaskInvocationParameters /// values for Comment, NotificationConfig, and OutputS3BucketName. /// If you update the maintenance window task and specify only a different OutputS3BucketName /// value, the values for Comment and NotificationConfig are /// removed. /// /// ///

/// Container for the necessary parameters to execute the UpdateMaintenanceWindowTask service method. /// /// The response from the UpdateMaintenanceWindowTask 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 UpdateMaintenanceWindowTask Operation public virtual UpdateMaintenanceWindowTaskResponse UpdateMaintenanceWindowTask(UpdateMaintenanceWindowTaskRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateMaintenanceWindowTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateMaintenanceWindowTaskResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateMaintenanceWindowTask operation. ///

/// /// Container for the necessary parameters to execute the UpdateMaintenanceWindowTask operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateMaintenanceWindowTask /// operation. /// REST API Reference for UpdateMaintenanceWindowTask Operation public virtual IAsyncResult BeginUpdateMaintenanceWindowTask(UpdateMaintenanceWindowTaskRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateMaintenanceWindowTaskRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateMaintenanceWindowTaskResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateMaintenanceWindowTask operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateMaintenanceWindowTask. /// /// Returns a UpdateMaintenanceWindowTaskResult from SimpleSystemsManagement. /// REST API Reference for UpdateMaintenanceWindowTask Operation public virtual UpdateMaintenanceWindowTaskResponse EndUpdateMaintenanceWindowTask(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateManagedInstanceRole ///

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

/// Container for the necessary parameters to execute the UpdateManagedInstanceRole service method. /// /// The response from the UpdateManagedInstanceRole 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 UpdateManagedInstanceRole Operation public virtual UpdateManagedInstanceRoleResponse UpdateManagedInstanceRole(UpdateManagedInstanceRoleRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateManagedInstanceRoleRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateManagedInstanceRoleResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateManagedInstanceRole operation. ///

/// /// Container for the necessary parameters to execute the UpdateManagedInstanceRole operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateManagedInstanceRole /// operation. /// REST API Reference for UpdateManagedInstanceRole Operation public virtual IAsyncResult BeginUpdateManagedInstanceRole(UpdateManagedInstanceRoleRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateManagedInstanceRoleRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateManagedInstanceRoleResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateManagedInstanceRole operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateManagedInstanceRole. /// /// Returns a UpdateManagedInstanceRoleResult from SimpleSystemsManagement. /// REST API Reference for UpdateManagedInstanceRole Operation public virtual UpdateManagedInstanceRoleResponse EndUpdateManagedInstanceRole(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateOpsItem ///

/// Edit or change an OpsItem. You must have permission in Identity and Access Management /// (IAM) to update an OpsItem. For more information, see Set /// up OpsCenter in the Amazon Web Services Systems Manager User Guide. /// /// /// /// Operations engineers and IT professionals use Amazon Web Services Systems Manager /// OpsCenter to view, investigate, and remediate operational issues impacting the performance /// and health of their Amazon Web Services resources. For more information, see OpsCenter /// in the Amazon Web Services Systems Manager User Guide. /// ///

/// Container for the necessary parameters to execute the UpdateOpsItem service method. /// /// The response from the UpdateOpsItem 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. /// /// /// The specified OpsItem ID doesn't exist. Verify the ID and try again. /// /// REST API Reference for UpdateOpsItem Operation public virtual UpdateOpsItemResponse UpdateOpsItem(UpdateOpsItemRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateOpsItemRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateOpsItemResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateOpsItem operation. ///

/// /// Container for the necessary parameters to execute the UpdateOpsItem operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateOpsItem /// operation. /// REST API Reference for UpdateOpsItem Operation public virtual IAsyncResult BeginUpdateOpsItem(UpdateOpsItemRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateOpsItemRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateOpsItemResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateOpsItem operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateOpsItem. /// /// Returns a UpdateOpsItemResult from SimpleSystemsManagement. /// REST API Reference for UpdateOpsItem Operation public virtual UpdateOpsItemResponse EndUpdateOpsItem(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateOpsMetadata ///

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

/// Container for the necessary parameters to execute the UpdateOpsMetadata service method. /// /// The response from the UpdateOpsMetadata service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// One of the arguments passed is invalid. /// /// /// The OpsMetadata object exceeds the maximum number of OpsMetadata keys that you can /// assign to an application in Application Manager. /// /// /// The OpsMetadata object doesn't exist. /// /// /// The system is processing too many concurrent updates. Wait a few moments and try again. /// /// REST API Reference for UpdateOpsMetadata Operation public virtual UpdateOpsMetadataResponse UpdateOpsMetadata(UpdateOpsMetadataRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateOpsMetadataResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateOpsMetadata operation. ///

/// /// Container for the necessary parameters to execute the UpdateOpsMetadata operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateOpsMetadata /// operation. /// REST API Reference for UpdateOpsMetadata Operation public virtual IAsyncResult BeginUpdateOpsMetadata(UpdateOpsMetadataRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateOpsMetadataRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateOpsMetadataResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateOpsMetadata operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateOpsMetadata. /// /// Returns a UpdateOpsMetadataResult from SimpleSystemsManagement. /// REST API Reference for UpdateOpsMetadata Operation public virtual UpdateOpsMetadataResponse EndUpdateOpsMetadata(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdatePatchBaseline ///

/// Modifies an existing patch baseline. Fields not specified in the request are left /// unchanged. /// /// /// /// For information about valid key-value pairs in PatchFilters for each /// supported operating system type, see PatchFilter. /// /// ///

/// Container for the necessary parameters to execute the UpdatePatchBaseline service method. /// /// The response from the UpdatePatchBaseline 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 UpdatePatchBaseline Operation public virtual UpdatePatchBaselineResponse UpdatePatchBaseline(UpdatePatchBaselineRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdatePatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdatePatchBaselineResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdatePatchBaseline operation. ///

/// /// Container for the necessary parameters to execute the UpdatePatchBaseline operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdatePatchBaseline /// operation. /// REST API Reference for UpdatePatchBaseline Operation public virtual IAsyncResult BeginUpdatePatchBaseline(UpdatePatchBaselineRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdatePatchBaselineRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdatePatchBaselineResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdatePatchBaseline operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdatePatchBaseline. /// /// Returns a UpdatePatchBaselineResult from SimpleSystemsManagement. /// REST API Reference for UpdatePatchBaseline Operation public virtual UpdatePatchBaselineResponse EndUpdatePatchBaseline(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateResourceDataSync ///

/// Update a resource data sync. After you create a resource data sync for a Region, you /// can't change the account options for that sync. For example, if you create a sync /// in the us-east-2 (Ohio) Region and you choose the Include only the current account /// option, you can't edit that sync later and choose the

Include all accounts from
        /// my Organizations configuration

option. Instead, you must delete the first resource /// data sync, and create a new one. /// /// /// /// This API operation only supports a resource data sync that was created with a SyncFromSource /// SyncType. /// /// ///

/// Container for the necessary parameters to execute the UpdateResourceDataSync service method. /// /// The response from the UpdateResourceDataSync service method, as returned by SimpleSystemsManagement. /// /// An error occurred on the server side. /// /// /// Another UpdateResourceDataSync request is being processed. Wait a few /// minutes and try again. /// /// /// The specified sync configuration is invalid. /// /// /// The specified sync name wasn't found. /// /// REST API Reference for UpdateResourceDataSync Operation public virtual UpdateResourceDataSyncResponse UpdateResourceDataSync(UpdateResourceDataSyncRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateResourceDataSyncResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateResourceDataSync operation. ///

/// /// Container for the necessary parameters to execute the UpdateResourceDataSync operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateResourceDataSync /// operation. /// REST API Reference for UpdateResourceDataSync Operation public virtual IAsyncResult BeginUpdateResourceDataSync(UpdateResourceDataSyncRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateResourceDataSyncRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateResourceDataSyncResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateResourceDataSync operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateResourceDataSync. /// /// Returns a UpdateResourceDataSyncResult from SimpleSystemsManagement. /// REST API Reference for UpdateResourceDataSync Operation public virtual UpdateResourceDataSyncResponse EndUpdateResourceDataSync(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateServiceSetting ///

/// ServiceSetting is an account-level setting for an Amazon Web Services /// service. This setting defines how a user interacts with or uses a service or a feature /// of a service. For example, if an Amazon Web Services service charges money to the /// account based on feature or service usage, then the Amazon Web Services service team /// might create a default setting of "false". This means the user can't use this feature /// unless they change the setting to "true" and intentionally opt in for a paid feature. /// /// /// /// Services map a SettingId object to a setting value. Amazon Web Services /// services teams define the default value for a SettingId. You can't create /// a new SettingId, but you can overwrite the default value if you have /// the ssm:UpdateServiceSetting permission for the setting. Use the GetServiceSetting /// API operation to view the current value. Or, use the ResetServiceSetting to /// change the value back to the original value defined by the Amazon Web Services service /// team. /// /// /// /// Update the service setting for the account. /// ///

/// Container for the necessary parameters to execute the UpdateServiceSetting service method. /// /// The response from the UpdateServiceSetting 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 UpdateServiceSetting Operation public virtual UpdateServiceSettingResponse UpdateServiceSetting(UpdateServiceSettingRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateServiceSettingRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateServiceSettingResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateServiceSetting operation. ///

/// /// Container for the necessary parameters to execute the UpdateServiceSetting operation on AmazonSimpleSystemsManagementClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateServiceSetting /// operation. /// REST API Reference for UpdateServiceSetting Operation public virtual IAsyncResult BeginUpdateServiceSetting(UpdateServiceSettingRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateServiceSettingRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateServiceSettingResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateServiceSetting operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateServiceSetting. /// /// Returns a UpdateServiceSettingResult from SimpleSystemsManagement. /// REST API Reference for UpdateServiceSetting Operation public virtual UpdateServiceSettingResponse EndUpdateServiceSetting(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }