@aws-sdk/client-ssm 3.35.0 → 3.38.0

package/dist-types/ts3.4/commands/StartAssociationsOnceCommand.d.ts

@@ -6,30 +6,11 @@ export interface StartAssociationsOnceCommandInput extends StartAssociationsOnce
 }
 export interface StartAssociationsOnceCommandOutput extends StartAssociationsOnceResult, __MetadataBearer {
 }
-/**
- * <p>Runs an association immediately and only one time. This operation can be helpful when
- *    troubleshooting associations.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, StartAssociationsOnceCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, StartAssociationsOnceCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new StartAssociationsOnceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartAssociationsOnceCommandInput} for command's `input` shape.
- * @see {@link StartAssociationsOnceCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartAssociationsOnceCommand extends $Command<StartAssociationsOnceCommandInput, StartAssociationsOnceCommandOutput, SSMClientResolvedConfig> {
     readonly input: StartAssociationsOnceCommandInput;
     constructor(input: StartAssociationsOnceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartAssociationsOnceCommandInput, StartAssociationsOnceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StartAutomationExecutionCommand.d.ts

@@ -6,29 +6,11 @@ export interface StartAutomationExecutionCommandInput extends StartAutomationExe
 }
 export interface StartAutomationExecutionCommandOutput extends StartAutomationExecutionResult, __MetadataBearer {
 }
-/**
- * <p>Initiates execution of an Automation runbook.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, StartAutomationExecutionCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, StartAutomationExecutionCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new StartAutomationExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartAutomationExecutionCommandInput} for command's `input` shape.
- * @see {@link StartAutomationExecutionCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartAutomationExecutionCommand extends $Command<StartAutomationExecutionCommandInput, StartAutomationExecutionCommandOutput, SSMClientResolvedConfig> {
     readonly input: StartAutomationExecutionCommandInput;
     constructor(input: StartAutomationExecutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartAutomationExecutionCommandInput, StartAutomationExecutionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StartChangeRequestExecutionCommand.d.ts

@@ -6,31 +6,11 @@ export interface StartChangeRequestExecutionCommandInput extends StartChangeRequ
 }
 export interface StartChangeRequestExecutionCommandOutput extends StartChangeRequestExecutionResult, __MetadataBearer {
 }
-/**
- * <p>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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, StartChangeRequestExecutionCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, StartChangeRequestExecutionCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new StartChangeRequestExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartChangeRequestExecutionCommandInput} for command's `input` shape.
- * @see {@link StartChangeRequestExecutionCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartChangeRequestExecutionCommand extends $Command<StartChangeRequestExecutionCommandInput, StartChangeRequestExecutionCommandOutput, SSMClientResolvedConfig> {
     readonly input: StartChangeRequestExecutionCommandInput;
     constructor(input: StartChangeRequestExecutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartChangeRequestExecutionCommandInput, StartChangeRequestExecutionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StartSessionCommand.d.ts

@@ -6,38 +6,11 @@ export interface StartSessionCommandInput extends StartSessionRequest {
 }
 export interface StartSessionCommandOutput extends StartSessionResponse, __MetadataBearer {
 }
-/**
- * <p>Initiates a connection to a target (for example, an instance) 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.</p>
- *          <note>
- *             <p>Amazon Web Services CLI usage: <code>start-session</code> is an interactive command that requires the Session Manager
- *     plugin to be installed on the client machine making the call. For information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html">Install
- *      the Session Manager plugin for the Amazon Web Services CLI</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
- *             <p>Amazon Web Services Tools for PowerShell usage: Start-SSMSession isn't currently supported by Amazon Web Services Tools
- *     for PowerShell on Windows local machines.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, StartSessionCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, StartSessionCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new StartSessionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartSessionCommandInput} for command's `input` shape.
- * @see {@link StartSessionCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartSessionCommand extends $Command<StartSessionCommandInput, StartSessionCommandOutput, SSMClientResolvedConfig> {
     readonly input: StartSessionCommandInput;
     constructor(input: StartSessionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartSessionCommandInput, StartSessionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StopAutomationExecutionCommand.d.ts

@@ -6,29 +6,11 @@ export interface StopAutomationExecutionCommandInput extends StopAutomationExecu
 }
 export interface StopAutomationExecutionCommandOutput extends StopAutomationExecutionResult, __MetadataBearer {
 }
-/**
- * <p>Stop an Automation that is currently running.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, StopAutomationExecutionCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, StopAutomationExecutionCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new StopAutomationExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopAutomationExecutionCommandInput} for command's `input` shape.
- * @see {@link StopAutomationExecutionCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopAutomationExecutionCommand extends $Command<StopAutomationExecutionCommandInput, StopAutomationExecutionCommandOutput, SSMClientResolvedConfig> {
     readonly input: StopAutomationExecutionCommandInput;
     constructor(input: StopAutomationExecutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopAutomationExecutionCommandInput, StopAutomationExecutionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/TerminateSessionCommand.d.ts

@@ -6,30 +6,11 @@ export interface TerminateSessionCommandInput extends TerminateSessionRequest {
 }
 export interface TerminateSessionCommandOutput extends TerminateSessionResponse, __MetadataBearer {
 }
-/**
- * <p>Permanently ends a session and closes the data connection between the Session Manager client and
- *    SSM Agent on the instance. A terminated session isn't be resumed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, TerminateSessionCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, TerminateSessionCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new TerminateSessionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TerminateSessionCommandInput} for command's `input` shape.
- * @see {@link TerminateSessionCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TerminateSessionCommand extends $Command<TerminateSessionCommandInput, TerminateSessionCommandOutput, SSMClientResolvedConfig> {
     readonly input: TerminateSessionCommandInput;
     constructor(input: TerminateSessionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TerminateSessionCommandInput, TerminateSessionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UnlabelParameterVersionCommand.d.ts

@@ -6,29 +6,11 @@ export interface UnlabelParameterVersionCommandInput extends UnlabelParameterVer
 }
 export interface UnlabelParameterVersionCommandOutput extends UnlabelParameterVersionResult, __MetadataBearer {
 }
-/**
- * <p>Remove a label or labels from a parameter.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, UnlabelParameterVersionCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, UnlabelParameterVersionCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new UnlabelParameterVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UnlabelParameterVersionCommandInput} for command's `input` shape.
- * @see {@link UnlabelParameterVersionCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UnlabelParameterVersionCommand extends $Command<UnlabelParameterVersionCommandInput, UnlabelParameterVersionCommandOutput, SSMClientResolvedConfig> {
     readonly input: UnlabelParameterVersionCommandInput;
     constructor(input: UnlabelParameterVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UnlabelParameterVersionCommandInput, UnlabelParameterVersionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateAssociationCommand.d.ts

@@ -6,41 +6,11 @@ export interface UpdateAssociationCommandInput extends UpdateAssociationRequest
 }
 export interface UpdateAssociationCommandOutput extends UpdateAssociationResult, __MetadataBearer {
 }
-/**
- * <p>Updates an association. You can update the association name and version, the document
- *    version, schedule, parameters, and Amazon Simple Storage Service (Amazon S3) output. </p>
- *          <p>In order to call this API operation, your Identity and Access Management (IAM) user
- *    account, group, or role must be configured with permission to call the <a>DescribeAssociation</a> API operation. If you don't have permission to call
- *     <code>DescribeAssociation</code>, then you receive the following error: <code>An error occurred
- *     (AccessDeniedException) when calling the UpdateAssociation operation: User: <user_arn>
- *     isn't authorized to perform: ssm:DescribeAssociation on resource:
- *    <resource_arn></code>
- *          </p>
- *          <important>
- *             <p>When you update an association, the association immediately runs against the specified
- *     targets.</p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, UpdateAssociationCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, UpdateAssociationCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new UpdateAssociationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateAssociationCommandInput} for command's `input` shape.
- * @see {@link UpdateAssociationCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateAssociationCommand extends $Command<UpdateAssociationCommandInput, UpdateAssociationCommandOutput, SSMClientResolvedConfig> {
     readonly input: UpdateAssociationCommandInput;
     constructor(input: UpdateAssociationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAssociationCommandInput, UpdateAssociationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateAssociationStatusCommand.d.ts

@@ -6,34 +6,11 @@ export interface UpdateAssociationStatusCommandInput extends UpdateAssociationSt
 }
 export interface UpdateAssociationStatusCommandOutput extends UpdateAssociationStatusResult, __MetadataBearer {
 }
-/**
- * <p>Updates the status of the Amazon Web Services Systems Manager document (SSM document) associated with the specified
- *    instance.</p>
- *          <p>
- *             <code>UpdateAssociationStatus</code> 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
- *     <code>InstanceId</code> legacy parameter.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, UpdateAssociationStatusCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, UpdateAssociationStatusCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new UpdateAssociationStatusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateAssociationStatusCommandInput} for command's `input` shape.
- * @see {@link UpdateAssociationStatusCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateAssociationStatusCommand extends $Command<UpdateAssociationStatusCommandInput, UpdateAssociationStatusCommandOutput, SSMClientResolvedConfig> {
     readonly input: UpdateAssociationStatusCommandInput;
     constructor(input: UpdateAssociationStatusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAssociationStatusCommandInput, UpdateAssociationStatusCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateDocumentCommand.d.ts

@@ -6,29 +6,11 @@ export interface UpdateDocumentCommandInput extends UpdateDocumentRequest {
 }
 export interface UpdateDocumentCommandOutput extends UpdateDocumentResult, __MetadataBearer {
 }
-/**
- * <p>Updates one or more values for an SSM document.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, UpdateDocumentCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, UpdateDocumentCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new UpdateDocumentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateDocumentCommandInput} for command's `input` shape.
- * @see {@link UpdateDocumentCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateDocumentCommand extends $Command<UpdateDocumentCommandInput, UpdateDocumentCommandOutput, SSMClientResolvedConfig> {
     readonly input: UpdateDocumentCommandInput;
     constructor(input: UpdateDocumentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDocumentCommandInput, UpdateDocumentCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateDocumentDefaultVersionCommand.d.ts

@@ -6,29 +6,11 @@ export interface UpdateDocumentDefaultVersionCommandInput extends UpdateDocument
 }
 export interface UpdateDocumentDefaultVersionCommandOutput extends UpdateDocumentDefaultVersionResult, __MetadataBearer {
 }
-/**
- * <p>Set the default version of a document. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, UpdateDocumentDefaultVersionCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, UpdateDocumentDefaultVersionCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new UpdateDocumentDefaultVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateDocumentDefaultVersionCommandInput} for command's `input` shape.
- * @see {@link UpdateDocumentDefaultVersionCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateDocumentDefaultVersionCommand extends $Command<UpdateDocumentDefaultVersionCommandInput, UpdateDocumentDefaultVersionCommandOutput, SSMClientResolvedConfig> {
     readonly input: UpdateDocumentDefaultVersionCommandInput;
     constructor(input: UpdateDocumentDefaultVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDocumentDefaultVersionCommandInput, UpdateDocumentDefaultVersionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateDocumentMetadataCommand.d.ts

@@ -6,30 +6,11 @@ export interface UpdateDocumentMetadataCommandInput extends UpdateDocumentMetada
 }
 export interface UpdateDocumentMetadataCommandOutput extends UpdateDocumentMetadataResponse, __MetadataBearer {
 }
-/**
- * <p>Updates information related to approval reviews for a specific version of a change template
- *    in Change Manager.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, UpdateDocumentMetadataCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, UpdateDocumentMetadataCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new UpdateDocumentMetadataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateDocumentMetadataCommandInput} for command's `input` shape.
- * @see {@link UpdateDocumentMetadataCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateDocumentMetadataCommand extends $Command<UpdateDocumentMetadataCommandInput, UpdateDocumentMetadataCommandOutput, SSMClientResolvedConfig> {
     readonly input: UpdateDocumentMetadataCommandInput;
     constructor(input: UpdateDocumentMetadataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDocumentMetadataCommandInput, UpdateDocumentMetadataCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateMaintenanceWindowCommand.d.ts

@@ -7,37 +7,11 @@ export interface UpdateMaintenanceWindowCommandInput extends UpdateMaintenanceWi
 }
 export interface UpdateMaintenanceWindowCommandOutput extends UpdateMaintenanceWindowResult, __MetadataBearer {
 }
-/**
- * <p>Updates an existing maintenance window. Only specified parameters are modified.</p>
- *          <note>
- *             <p>The value you specify for <code>Duration</code> 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 <code>Cutoff</code>.
- *     For example, if the maintenance window starts at 3 PM, the duration is three hours, and the
- *     value you specify for <code>Cutoff</code> is one hour, no maintenance window tasks can start
- *     after 5 PM.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, UpdateMaintenanceWindowCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, UpdateMaintenanceWindowCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new UpdateMaintenanceWindowCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateMaintenanceWindowCommandInput} for command's `input` shape.
- * @see {@link UpdateMaintenanceWindowCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateMaintenanceWindowCommand extends $Command<UpdateMaintenanceWindowCommandInput, UpdateMaintenanceWindowCommandOutput, SSMClientResolvedConfig> {
     readonly input: UpdateMaintenanceWindowCommandInput;
     constructor(input: UpdateMaintenanceWindowCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateMaintenanceWindowCommandInput, UpdateMaintenanceWindowCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateMaintenanceWindowTargetCommand.d.ts

@@ -6,55 +6,11 @@ export interface UpdateMaintenanceWindowTargetCommandInput extends UpdateMainten
 }
 export interface UpdateMaintenanceWindowTargetCommandOutput extends UpdateMaintenanceWindowTargetResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the target of an existing maintenance window. You
- *    can change the following:</p>
- *
- *          <ul>
- *             <li>
- *                <p>Name</p>
- *             </li>
- *             <li>
- *                <p>Description</p>
- *             </li>
- *             <li>
- *                <p>Owner</p>
- *             </li>
- *             <li>
- *                <p>IDs for an ID target</p>
- *             </li>
- *             <li>
- *                <p>Tags for a Tag target</p>
- *             </li>
- *             <li>
- *                <p>From any supported tag type to another. The three supported tag types are ID target, Tag
- *      target, and resource group. For more information, see <a>Target</a>.</p>
- *             </li>
- *          </ul>
- *          <note>
- *             <p>If a parameter is null, then the corresponding field isn't modified.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, UpdateMaintenanceWindowTargetCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, UpdateMaintenanceWindowTargetCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new UpdateMaintenanceWindowTargetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateMaintenanceWindowTargetCommandInput} for command's `input` shape.
- * @see {@link UpdateMaintenanceWindowTargetCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateMaintenanceWindowTargetCommand extends $Command<UpdateMaintenanceWindowTargetCommandInput, UpdateMaintenanceWindowTargetCommandOutput, SSMClientResolvedConfig> {
     readonly input: UpdateMaintenanceWindowTargetCommandInput;
     constructor(input: UpdateMaintenanceWindowTargetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateMaintenanceWindowTargetCommandInput, UpdateMaintenanceWindowTargetCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateMaintenanceWindowTaskCommand.d.ts

@@ -6,84 +6,11 @@ export interface UpdateMaintenanceWindowTaskCommandInput extends UpdateMaintenan
 }
 export interface UpdateMaintenanceWindowTaskCommandOutput extends UpdateMaintenanceWindowTaskResult, __MetadataBearer {
 }
-/**
- * <p>Modifies a task assigned to a maintenance window. You can't change the task type, but you
- *    can change the following values:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <code>TaskARN</code>. For example, you can change a <code>RUN_COMMAND</code> task from
- *       <code>AWS-RunPowerShellScript</code> to <code>AWS-RunShellScript</code>.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>ServiceRoleArn</code>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>TaskInvocationParameters</code>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>Priority</code>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>MaxConcurrency</code>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>MaxErrors</code>
- *                </p>
- *             </li>
- *          </ul>
- *          <note>
- *             <p>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 <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/maintenance-windows-targetless-tasks.html">Registering
- *      maintenance window tasks without targets</a> in the
- *     <i>Amazon Web Services Systems Manager User Guide</i>.</p>
- *          </note>
- *          <p>If the value for a parameter in <code>UpdateMaintenanceWindowTask</code> is null, then the
- *    corresponding field isn't modified. If you set <code>Replace</code> to true, then all fields
- *    required by the <a>RegisterTaskWithMaintenanceWindow</a> operation are required for
- *    this request. Optional fields that aren't specified are set to null.</p>
- *          <important>
- *             <p>When you update a maintenance window task that has options specified in
- *      <code>TaskInvocationParameters</code>, you must provide again all the
- *      <code>TaskInvocationParameters</code> 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 <code>TaskInvocationParameters</code> values for <code>Comment</code>,
- *      <code>NotificationConfig</code>, and <code>OutputS3BucketName</code>. If you update the
- *     maintenance window task and specify only a different <code>OutputS3BucketName</code> value, the
- *     values for <code>Comment</code> and <code>NotificationConfig</code> are removed.</p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, UpdateMaintenanceWindowTaskCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, UpdateMaintenanceWindowTaskCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new UpdateMaintenanceWindowTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateMaintenanceWindowTaskCommandInput} for command's `input` shape.
- * @see {@link UpdateMaintenanceWindowTaskCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateMaintenanceWindowTaskCommand extends $Command<UpdateMaintenanceWindowTaskCommandInput, UpdateMaintenanceWindowTaskCommandOutput, SSMClientResolvedConfig> {
     readonly input: UpdateMaintenanceWindowTaskCommandInput;
     constructor(input: UpdateMaintenanceWindowTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateMaintenanceWindowTaskCommandInput, UpdateMaintenanceWindowTaskCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateManagedInstanceRoleCommand.d.ts

@@ -6,31 +6,11 @@ export interface UpdateManagedInstanceRoleCommandInput extends UpdateManagedInst
 }
 export interface UpdateManagedInstanceRoleCommandOutput extends UpdateManagedInstanceRoleResult, __MetadataBearer {
 }
-/**
- * <p>Changes the Identity and Access Management (IAM) role that is assigned to the
- *    on-premises instance or virtual machines (VM). IAM roles are first assigned to
- *    these hybrid instances during the activation process. For more information, see <a>CreateActivation</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, UpdateManagedInstanceRoleCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, UpdateManagedInstanceRoleCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new UpdateManagedInstanceRoleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateManagedInstanceRoleCommandInput} for command's `input` shape.
- * @see {@link UpdateManagedInstanceRoleCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateManagedInstanceRoleCommand extends $Command<UpdateManagedInstanceRoleCommandInput, UpdateManagedInstanceRoleCommandOutput, SSMClientResolvedConfig> {
     readonly input: UpdateManagedInstanceRoleCommandInput;
     constructor(input: UpdateManagedInstanceRoleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateManagedInstanceRoleCommandInput, UpdateManagedInstanceRoleCommandOutput>;
     private serialize;
     private deserialize;