@aws-sdk/client-ssm 3.34.0 → 3.37.0

package/dist-types/commands/ListTagsForResourceCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListTagsForResourceRequest, ListTagsForResourceResult } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResult, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of the tags assigned to the specified resource.</p>
+ *          <p>For information about the ID format for each supported resource type, see <a>AddTagsToResource</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, ListTagsForResourceCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, ListTagsForResourceCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, SSMClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ModifyDocumentPermissionCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ModifyDocumentPermissionRequest, ModifyDocumentPermissionResponse } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface ModifyDocumentPermissionCommandInput extends ModifyDocumentPermissionRequest {
+}
+export interface ModifyDocumentPermissionCommandOutput extends ModifyDocumentPermissionResponse, __MetadataBearer {
+}
+/**
+ * <p>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 account IDs for those people who can use the
+ *    document. If you share a document publicly, you must specify <i>All</i> as the
+ *    account ID.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, ModifyDocumentPermissionCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, ModifyDocumentPermissionCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new ModifyDocumentPermissionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ModifyDocumentPermissionCommandInput} for command's `input` shape.
+ * @see {@link ModifyDocumentPermissionCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ModifyDocumentPermissionCommand extends $Command<ModifyDocumentPermissionCommandInput, ModifyDocumentPermissionCommandOutput, SSMClientResolvedConfig> {
+    readonly input: ModifyDocumentPermissionCommandInput;
+    constructor(input: ModifyDocumentPermissionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyDocumentPermissionCommandInput, ModifyDocumentPermissionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutComplianceItemsCommand.d.ts

@@ -0,0 +1,90 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PutComplianceItemsRequest, PutComplianceItemsResult } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface PutComplianceItemsCommandInput extends PutComplianceItemsRequest {
+}
+export interface PutComplianceItemsCommandOutput extends PutComplianceItemsResult, __MetadataBearer {
+}
+/**
+ * <p>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.</p>
+ *          <p>ComplianceType can be one of the following:</p>
+ *          <ul>
+ *             <li>
+ *                <p>ExecutionId: The execution ID when the patch, association, or custom compliance item was
+ *      applied.</p>
+ *             </li>
+ *             <li>
+ *                <p>ExecutionType: Specify patch, association, or Custom:<code>string</code>.</p>
+ *             </li>
+ *             <li>
+ *                <p>ExecutionTime. The time the patch, association, or custom compliance item was applied to
+ *      the instance.</p>
+ *             </li>
+ *             <li>
+ *                <p>Id: The patch, association, or custom compliance ID.</p>
+ *             </li>
+ *             <li>
+ *                <p>Title: A title.</p>
+ *             </li>
+ *             <li>
+ *                <p>Status: The status of the compliance item. For example, <code>approved</code> for patches,
+ *      or <code>Failed</code> for associations.</p>
+ *             </li>
+ *             <li>
+ *                <p>Severity: A patch severity. For example, <code>critical</code>.</p>
+ *             </li>
+ *             <li>
+ *                <p>DocumentName: An SSM document name. For example, <code>AWS-RunPatchBaseline</code>.</p>
+ *             </li>
+ *             <li>
+ *                <p>DocumentVersion: An SSM document version number. For example, 4.</p>
+ *             </li>
+ *             <li>
+ *                <p>Classification: A patch classification. For example, <code>security updates</code>.</p>
+ *             </li>
+ *             <li>
+ *                <p>PatchBaselineId: A patch baseline ID.</p>
+ *             </li>
+ *             <li>
+ *                <p>PatchSeverity: A patch severity. For example, <code>Critical</code>.</p>
+ *             </li>
+ *             <li>
+ *                <p>PatchState: A patch state. For example, <code>InstancesWithFailedPatches</code>.</p>
+ *             </li>
+ *             <li>
+ *                <p>PatchGroup: The name of a patch group.</p>
+ *             </li>
+ *             <li>
+ *                <p>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'</p>
+ *             </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, PutComplianceItemsCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, PutComplianceItemsCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new PutComplianceItemsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutComplianceItemsCommandInput} for command's `input` shape.
+ * @see {@link PutComplianceItemsCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutComplianceItemsCommand extends $Command<PutComplianceItemsCommandInput, PutComplianceItemsCommandOutput, SSMClientResolvedConfig> {
+    readonly input: PutComplianceItemsCommandInput;
+    constructor(input: PutComplianceItemsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutComplianceItemsCommandInput, PutComplianceItemsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutInventoryCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PutInventoryRequest, PutInventoryResult } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface PutInventoryCommandInput extends PutInventoryRequest {
+}
+export interface PutInventoryCommandOutput extends PutInventoryResult, __MetadataBearer {
+}
+/**
+ * <p>Bulk update custom inventory items on one more instance. The request adds an inventory item,
+ *    if it doesn't already exist, or updates an inventory item, if it does exist.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, PutInventoryCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, PutInventoryCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new PutInventoryCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutInventoryCommandInput} for command's `input` shape.
+ * @see {@link PutInventoryCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutInventoryCommand extends $Command<PutInventoryCommandInput, PutInventoryCommandOutput, SSMClientResolvedConfig> {
+    readonly input: PutInventoryCommandInput;
+    constructor(input: PutInventoryCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutInventoryCommandInput, PutInventoryCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutParameterCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PutParameterRequest, PutParameterResult } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface PutParameterCommandInput extends PutParameterRequest {
+}
+export interface PutParameterCommandOutput extends PutParameterResult, __MetadataBearer {
+}
+/**
+ * <p>Add a parameter to the system.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, PutParameterCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, PutParameterCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new PutParameterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutParameterCommandInput} for command's `input` shape.
+ * @see {@link PutParameterCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutParameterCommand extends $Command<PutParameterCommandInput, PutParameterCommandOutput, SSMClientResolvedConfig> {
+    readonly input: PutParameterCommandInput;
+    constructor(input: PutParameterCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutParameterCommandInput, PutParameterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RegisterDefaultPatchBaselineCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RegisterDefaultPatchBaselineRequest, RegisterDefaultPatchBaselineResult } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface RegisterDefaultPatchBaselineCommandInput extends RegisterDefaultPatchBaselineRequest {
+}
+export interface RegisterDefaultPatchBaselineCommandOutput extends RegisterDefaultPatchBaselineResult, __MetadataBearer {
+}
+/**
+ * <p>Defines the default patch baseline for the relevant operating system.</p>
+ *          <p>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
+ *     <code>arn:aws:ssm:us-east-2:733109147000:patchbaseline/pb-0574b43a65ea646ed</code> instead of
+ *     <code>pb-0574b43a65ea646ed</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, RegisterDefaultPatchBaselineCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, RegisterDefaultPatchBaselineCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new RegisterDefaultPatchBaselineCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RegisterDefaultPatchBaselineCommandInput} for command's `input` shape.
+ * @see {@link RegisterDefaultPatchBaselineCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RegisterDefaultPatchBaselineCommand extends $Command<RegisterDefaultPatchBaselineCommandInput, RegisterDefaultPatchBaselineCommandOutput, SSMClientResolvedConfig> {
+    readonly input: RegisterDefaultPatchBaselineCommandInput;
+    constructor(input: RegisterDefaultPatchBaselineCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterDefaultPatchBaselineCommandInput, RegisterDefaultPatchBaselineCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RegisterPatchBaselineForPatchGroupCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RegisterPatchBaselineForPatchGroupRequest, RegisterPatchBaselineForPatchGroupResult } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface RegisterPatchBaselineForPatchGroupCommandInput extends RegisterPatchBaselineForPatchGroupRequest {
+}
+export interface RegisterPatchBaselineForPatchGroupCommandOutput extends RegisterPatchBaselineForPatchGroupResult, __MetadataBearer {
+}
+/**
+ * <p>Registers a patch baseline for a patch group.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, RegisterPatchBaselineForPatchGroupCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, RegisterPatchBaselineForPatchGroupCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new RegisterPatchBaselineForPatchGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RegisterPatchBaselineForPatchGroupCommandInput} for command's `input` shape.
+ * @see {@link RegisterPatchBaselineForPatchGroupCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RegisterPatchBaselineForPatchGroupCommand extends $Command<RegisterPatchBaselineForPatchGroupCommandInput, RegisterPatchBaselineForPatchGroupCommandOutput, SSMClientResolvedConfig> {
+    readonly input: RegisterPatchBaselineForPatchGroupCommandInput;
+    constructor(input: RegisterPatchBaselineForPatchGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterPatchBaselineForPatchGroupCommandInput, RegisterPatchBaselineForPatchGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RegisterTargetWithMaintenanceWindowCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RegisterTargetWithMaintenanceWindowRequest, RegisterTargetWithMaintenanceWindowResult } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface RegisterTargetWithMaintenanceWindowCommandInput extends RegisterTargetWithMaintenanceWindowRequest {
+}
+export interface RegisterTargetWithMaintenanceWindowCommandOutput extends RegisterTargetWithMaintenanceWindowResult, __MetadataBearer {
+}
+/**
+ * <p>Registers a target with a maintenance window.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, RegisterTargetWithMaintenanceWindowCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, RegisterTargetWithMaintenanceWindowCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new RegisterTargetWithMaintenanceWindowCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RegisterTargetWithMaintenanceWindowCommandInput} for command's `input` shape.
+ * @see {@link RegisterTargetWithMaintenanceWindowCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RegisterTargetWithMaintenanceWindowCommand extends $Command<RegisterTargetWithMaintenanceWindowCommandInput, RegisterTargetWithMaintenanceWindowCommandOutput, SSMClientResolvedConfig> {
+    readonly input: RegisterTargetWithMaintenanceWindowCommandInput;
+    constructor(input: RegisterTargetWithMaintenanceWindowCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterTargetWithMaintenanceWindowCommandInput, RegisterTargetWithMaintenanceWindowCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RegisterTaskWithMaintenanceWindowCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RegisterTaskWithMaintenanceWindowRequest, RegisterTaskWithMaintenanceWindowResult } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface RegisterTaskWithMaintenanceWindowCommandInput extends RegisterTaskWithMaintenanceWindowRequest {
+}
+export interface RegisterTaskWithMaintenanceWindowCommandOutput extends RegisterTaskWithMaintenanceWindowResult, __MetadataBearer {
+}
+/**
+ * <p>Adds a new task to a maintenance window.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, RegisterTaskWithMaintenanceWindowCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, RegisterTaskWithMaintenanceWindowCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new RegisterTaskWithMaintenanceWindowCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RegisterTaskWithMaintenanceWindowCommandInput} for command's `input` shape.
+ * @see {@link RegisterTaskWithMaintenanceWindowCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RegisterTaskWithMaintenanceWindowCommand extends $Command<RegisterTaskWithMaintenanceWindowCommandInput, RegisterTaskWithMaintenanceWindowCommandOutput, SSMClientResolvedConfig> {
+    readonly input: RegisterTaskWithMaintenanceWindowCommandInput;
+    constructor(input: RegisterTaskWithMaintenanceWindowCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterTaskWithMaintenanceWindowCommandInput, RegisterTaskWithMaintenanceWindowCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RemoveTagsFromResourceCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RemoveTagsFromResourceRequest, RemoveTagsFromResourceResult } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface RemoveTagsFromResourceCommandInput extends RemoveTagsFromResourceRequest {
+}
+export interface RemoveTagsFromResourceCommandOutput extends RemoveTagsFromResourceResult, __MetadataBearer {
+}
+/**
+ * <p>Removes tag keys from the specified resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, RemoveTagsFromResourceCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, RemoveTagsFromResourceCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new RemoveTagsFromResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RemoveTagsFromResourceCommandInput} for command's `input` shape.
+ * @see {@link RemoveTagsFromResourceCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RemoveTagsFromResourceCommand extends $Command<RemoveTagsFromResourceCommandInput, RemoveTagsFromResourceCommandOutput, SSMClientResolvedConfig> {
+    readonly input: RemoveTagsFromResourceCommandInput;
+    constructor(input: RemoveTagsFromResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveTagsFromResourceCommandInput, RemoveTagsFromResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ResetServiceSettingCommand.d.ts

@@ -0,0 +1,49 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ResetServiceSettingRequest, ResetServiceSettingResult } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface ResetServiceSettingCommandInput extends ResetServiceSettingRequest {
+}
+export interface ResetServiceSettingCommandOutput extends ResetServiceSettingResult, __MetadataBearer {
+}
+/**
+ * <p>
+ *             <code>ServiceSetting</code> 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.</p>
+ *          <p>Services map a <code>SettingId</code> object to a setting value. Amazon Web Services services teams define
+ *    the default value for a <code>SettingId</code>. You can't create a new <code>SettingId</code>,
+ *    but you can overwrite the default value if you have the <code>ssm:UpdateServiceSetting</code>
+ *    permission for the setting. Use the <a>GetServiceSetting</a> API operation to view the
+ *    current value. Use the <a>UpdateServiceSetting</a> API operation to change the default
+ *    setting. </p>
+ *          <p>Reset the service setting for the account to the default value as provisioned by the Amazon Web Services
+ *    service team. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, ResetServiceSettingCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, ResetServiceSettingCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new ResetServiceSettingCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ResetServiceSettingCommandInput} for command's `input` shape.
+ * @see {@link ResetServiceSettingCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ResetServiceSettingCommand extends $Command<ResetServiceSettingCommandInput, ResetServiceSettingCommandOutput, SSMClientResolvedConfig> {
+    readonly input: ResetServiceSettingCommandInput;
+    constructor(input: ResetServiceSettingCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetServiceSettingCommandInput, ResetServiceSettingCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ResumeSessionCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ResumeSessionRequest, ResumeSessionResponse } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface ResumeSessionCommandInput extends ResumeSessionRequest {
+}
+export interface ResumeSessionCommandOutput extends ResumeSessionResponse, __MetadataBearer {
+}
+/**
+ * <p>Reconnects a session to an instance after it has been disconnected. Connections can be
+ *    resumed for disconnected sessions, but not terminated sessions.</p>
+ *          <note>
+ *             <p>This command is primarily for use by client machines to automatically reconnect during
+ *     intermittent network issues. It isn't intended for any other use.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, ResumeSessionCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, ResumeSessionCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new ResumeSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ResumeSessionCommandInput} for command's `input` shape.
+ * @see {@link ResumeSessionCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ResumeSessionCommand extends $Command<ResumeSessionCommandInput, ResumeSessionCommandOutput, SSMClientResolvedConfig> {
+    readonly input: ResumeSessionCommandInput;
+    constructor(input: ResumeSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResumeSessionCommandInput, ResumeSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SendAutomationSignalCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SendAutomationSignalRequest, SendAutomationSignalResult } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface SendAutomationSignalCommandInput extends SendAutomationSignalRequest {
+}
+export interface SendAutomationSignalCommandOutput extends SendAutomationSignalResult, __MetadataBearer {
+}
+/**
+ * <p>Sends a signal to an Automation execution to change the current behavior or status of the
+ *    execution. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, SendAutomationSignalCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, SendAutomationSignalCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new SendAutomationSignalCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SendAutomationSignalCommandInput} for command's `input` shape.
+ * @see {@link SendAutomationSignalCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SendAutomationSignalCommand extends $Command<SendAutomationSignalCommandInput, SendAutomationSignalCommandOutput, SSMClientResolvedConfig> {
+    readonly input: SendAutomationSignalCommandInput;
+    constructor(input: SendAutomationSignalCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendAutomationSignalCommandInput, SendAutomationSignalCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SendCommandCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SendCommandRequest, SendCommandResult } from "../models/models_1";
+import { ServiceInputTypes, ServiceOutputTypes, SSMClientResolvedConfig } from "../SSMClient";
+export interface SendCommandCommandInput extends SendCommandRequest {
+}
+export interface SendCommandCommandOutput extends SendCommandResult, __MetadataBearer {
+}
+/**
+ * <p>Runs commands on one or more managed instances.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SSMClient, SendCommandCommand } from "@aws-sdk/client-ssm"; // ES Modules import
+ * // const { SSMClient, SendCommandCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
+ * const client = new SSMClient(config);
+ * const command = new SendCommandCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SendCommandCommandInput} for command's `input` shape.
+ * @see {@link SendCommandCommandOutput} for command's `response` shape.
+ * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SendCommandCommand extends $Command<SendCommandCommandInput, SendCommandCommandOutput, SSMClientResolvedConfig> {
+    readonly input: SendCommandCommandInput;
+    constructor(input: SendCommandCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendCommandCommandInput, SendCommandCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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