@aws-sdk/client-ssm 3.34.0 → 3.37.0

package/dist/types/commands/StartAutomationExecutionCommand.d.ts

@@ -1,35 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { StartAutomationExecutionRequest, StartAutomationExecutionResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StartAutomationExecutionCommandInput extends StartAutomationExecutionRequest {
-}
-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/commands/StartChangeRequestExecutionCommand.d.ts

@@ -1,37 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { StartChangeRequestExecutionRequest, StartChangeRequestExecutionResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StartChangeRequestExecutionCommandInput extends StartChangeRequestExecutionRequest {
-}
-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/commands/StartSessionCommand.d.ts

@@ -1,44 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { StartSessionRequest, StartSessionResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/StopAutomationExecutionCommand.d.ts

@@ -1,35 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { StopAutomationExecutionRequest, StopAutomationExecutionResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StopAutomationExecutionCommandInput extends StopAutomationExecutionRequest {
-}
-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/commands/TerminateSessionCommand.d.ts

@@ -1,36 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { TerminateSessionRequest, TerminateSessionResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/UnlabelParameterVersionCommand.d.ts

@@ -1,35 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { UnlabelParameterVersionRequest, UnlabelParameterVersionResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UnlabelParameterVersionCommandInput extends UnlabelParameterVersionRequest {
-}
-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/commands/UpdateAssociationCommand.d.ts

@@ -1,47 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { UpdateAssociationRequest, UpdateAssociationResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/UpdateAssociationStatusCommand.d.ts

@@ -1,40 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { UpdateAssociationStatusRequest, UpdateAssociationStatusResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateAssociationStatusCommandInput extends UpdateAssociationStatusRequest {
-}
-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/commands/UpdateDocumentCommand.d.ts

@@ -1,35 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { UpdateDocumentRequest, UpdateDocumentResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/UpdateDocumentDefaultVersionCommand.d.ts

@@ -1,35 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { UpdateDocumentDefaultVersionRequest, UpdateDocumentDefaultVersionResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateDocumentDefaultVersionCommandInput extends UpdateDocumentDefaultVersionRequest {
-}
-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/commands/UpdateDocumentMetadataCommand.d.ts

@@ -1,36 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { UpdateDocumentMetadataRequest, UpdateDocumentMetadataResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateDocumentMetadataCommandInput extends UpdateDocumentMetadataRequest {
-}
-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/commands/UpdateMaintenanceWindowCommand.d.ts

@@ -1,44 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { UpdateMaintenanceWindowRequest } from "../models/models_1";
-import { UpdateMaintenanceWindowResult } from "../models/models_2";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateMaintenanceWindowCommandInput extends UpdateMaintenanceWindowRequest {
-}
-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/commands/UpdateMaintenanceWindowTargetCommand.d.ts

@@ -1,61 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { UpdateMaintenanceWindowTargetRequest, UpdateMaintenanceWindowTargetResult } from "../models/models_2";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateMaintenanceWindowTargetCommandInput extends UpdateMaintenanceWindowTargetRequest {
-}
-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/commands/UpdateMaintenanceWindowTaskCommand.d.ts

@@ -1,90 +0,0 @@
-import { SSMClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SSMClient";
-import { UpdateMaintenanceWindowTaskRequest, UpdateMaintenanceWindowTaskResult } from "../models/models_2";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateMaintenanceWindowTaskCommandInput extends UpdateMaintenanceWindowTaskRequest {
-}
-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;
-}