@aws-sdk/client-ssm 3.35.0 → 3.38.0

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

@@ -6,30 +6,11 @@ export interface CreateOpsMetadataCommandInput extends CreateOpsMetadataRequest
 }
 export interface CreateOpsMetadataCommandOutput extends CreateOpsMetadataResult, __MetadataBearer {
 }
-/**
- * <p>If you create a new application in Application Manager, Amazon Web Services Systems Manager calls this API operation to specify
- *    information about the new application, including the application type.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, CreateOpsMetadataCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, CreateOpsMetadataCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new CreateOpsMetadataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateOpsMetadataCommandInput} for command's `input` shape.
- * @see {@link CreateOpsMetadataCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateOpsMetadataCommand extends $Command<CreateOpsMetadataCommandInput, CreateOpsMetadataCommandOutput, SSMClientResolvedConfig> {
     readonly input: CreateOpsMetadataCommandInput;
     constructor(input: CreateOpsMetadataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateOpsMetadataCommandInput, CreateOpsMetadataCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface CreatePatchBaselineCommandInput extends CreatePatchBaselineRequ
 }
 export interface CreatePatchBaselineCommandOutput extends CreatePatchBaselineResult, __MetadataBearer {
 }
-/**
- * <p>Creates a patch baseline.</p>
- *          <note>
- *             <p>For information about valid key-value pairs in <code>PatchFilters</code> for each supported
- *     operating system type, see <a>PatchFilter</a>.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, CreatePatchBaselineCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, CreatePatchBaselineCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new CreatePatchBaselineCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreatePatchBaselineCommandInput} for command's `input` shape.
- * @see {@link CreatePatchBaselineCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreatePatchBaselineCommand extends $Command<CreatePatchBaselineCommandInput, CreatePatchBaselineCommandOutput, SSMClientResolvedConfig> {
     readonly input: CreatePatchBaselineCommandInput;
     constructor(input: CreatePatchBaselineCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePatchBaselineCommandInput, CreatePatchBaselineCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,49 +6,11 @@ export interface CreateResourceDataSyncCommandInput extends CreateResourceDataSy
 }
 export interface CreateResourceDataSyncCommandOutput extends CreateResourceDataSyncResult, __MetadataBearer {
 }
-/**
- * <p>A resource data sync helps you view data from multiple sources in a single location.
- *    Amazon Web Services Systems Manager offers two types of resource data sync: <code>SyncToDestination</code> and
- *     <code>SyncFromSource</code>.</p>
- *          <p>You can configure Systems Manager Inventory to use the <code>SyncToDestination</code> type to
- *    synchronize Inventory data from multiple Amazon Web Services Regions to a single Amazon Simple Storage Service (Amazon S3) bucket. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-inventory-datasync.html">Configuring resource data
- *     sync for Inventory</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
- *          <p>You can configure Systems Manager Explorer to use the <code>SyncFromSource</code> type to synchronize
- *    operational work items (OpsItems) and operational data (OpsData) from multiple Amazon Web Services Regions to a
- *    single Amazon S3 bucket. This type can synchronize OpsItems and OpsData from multiple
- *    Amazon Web Services accounts and Amazon Web Services Regions or <code>EntireOrganization</code> by using Organizations. For more
- *    information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/Explorer-resource-data-sync.html">Setting up Systems Manager
- *     Explorer to display data from multiple accounts and Regions</a> in the
- *     <i>Amazon Web Services Systems Manager User Guide</i>.</p>
- *          <p>A resource data sync is an asynchronous operation that returns immediately. After a
- *    successful initial sync is completed, the system continuously syncs data. To check the status of
- *    a sync, use the <a>ListResourceDataSync</a>.</p>
- *          <note>
- *             <p>By default, data isn't encrypted in Amazon S3. We strongly recommend that you
- *     enable encryption in Amazon S3 to ensure secure data storage. We also recommend that you
- *     secure access to the Amazon S3 bucket by creating a restrictive bucket policy. </p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, CreateResourceDataSyncCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, CreateResourceDataSyncCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new CreateResourceDataSyncCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateResourceDataSyncCommandInput} for command's `input` shape.
- * @see {@link CreateResourceDataSyncCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateResourceDataSyncCommand extends $Command<CreateResourceDataSyncCommandInput, CreateResourceDataSyncCommandOutput, SSMClientResolvedConfig> {
     readonly input: CreateResourceDataSyncCommandInput;
     constructor(input: CreateResourceDataSyncCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateResourceDataSyncCommandInput, CreateResourceDataSyncCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteActivationCommandInput extends DeleteActivationRequest {
 }
 export interface DeleteActivationCommandOutput extends DeleteActivationResult, __MetadataBearer {
 }
-/**
- * <p>Deletes an activation. You aren't required to delete an activation. If you delete an
- *    activation, you can no longer use it to register additional managed instances. Deleting an
- *    activation doesn't de-register managed instances. You must manually de-register managed
- *    instances.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, DeleteActivationCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, DeleteActivationCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new DeleteActivationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteActivationCommandInput} for command's `input` shape.
- * @see {@link DeleteActivationCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteActivationCommand extends $Command<DeleteActivationCommandInput, DeleteActivationCommandOutput, SSMClientResolvedConfig> {
     readonly input: DeleteActivationCommandInput;
     constructor(input: DeleteActivationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteActivationCommandInput, DeleteActivationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface DeleteAssociationCommandInput extends DeleteAssociationRequest
 }
 export interface DeleteAssociationCommandOutput extends DeleteAssociationResult, __MetadataBearer {
 }
-/**
- * <p>Disassociates the specified Amazon Web Services Systems Manager document (SSM document) from the specified instance.
- *    If you created the association by using the <code>Targets</code> parameter, then you must delete
- *    the association by using the association ID.</p>
- *          <p>When you disassociate a document from an instance, it doesn't change the configuration of
- *    the instance. To change the configuration state of an instance after you disassociate a document,
- *    you must create a new document with the desired configuration and associate it with the
- *    instance.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, DeleteAssociationCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, DeleteAssociationCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new DeleteAssociationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteAssociationCommandInput} for command's `input` shape.
- * @see {@link DeleteAssociationCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteAssociationCommand extends $Command<DeleteAssociationCommandInput, DeleteAssociationCommandOutput, SSMClientResolvedConfig> {
     readonly input: DeleteAssociationCommandInput;
     constructor(input: DeleteAssociationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAssociationCommandInput, DeleteAssociationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeleteDocumentCommandInput extends DeleteDocumentRequest {
 }
 export interface DeleteDocumentCommandOutput extends DeleteDocumentResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the Amazon Web Services Systems Manager document (SSM document) and all instance associations to the
- *    document.</p>
- *          <p>Before you delete the document, we recommend that you use <a>DeleteAssociation</a> to disassociate all instances that are associated with the document.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, DeleteDocumentCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, DeleteDocumentCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new DeleteDocumentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDocumentCommandInput} for command's `input` shape.
- * @see {@link DeleteDocumentCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDocumentCommand extends $Command<DeleteDocumentCommandInput, DeleteDocumentCommandOutput, SSMClientResolvedConfig> {
     readonly input: DeleteDocumentCommandInput;
     constructor(input: DeleteDocumentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDocumentCommandInput, DeleteDocumentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteInventoryCommandInput extends DeleteInventoryRequest {
 }
 export interface DeleteInventoryCommandOutput extends DeleteInventoryResult, __MetadataBearer {
 }
-/**
- * <p>Delete a custom inventory type or the data associated with a custom Inventory type. Deleting
- *    a custom inventory type is also referred to as deleting a custom inventory schema.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, DeleteInventoryCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, DeleteInventoryCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new DeleteInventoryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteInventoryCommandInput} for command's `input` shape.
- * @see {@link DeleteInventoryCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteInventoryCommand extends $Command<DeleteInventoryCommandInput, DeleteInventoryCommandOutput, SSMClientResolvedConfig> {
     readonly input: DeleteInventoryCommandInput;
     constructor(input: DeleteInventoryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteInventoryCommandInput, DeleteInventoryCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface DeleteParameterCommandInput extends DeleteParameterRequest {
 }
 export interface DeleteParameterCommandOutput extends DeleteParameterResult, __MetadataBearer {
 }
-/**
- * <p>Delete a parameter from the system. After deleting a parameter, wait for at least 30 seconds
- *    to create a parameter with the same name.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, DeleteParameterCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, DeleteParameterCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new DeleteParameterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteParameterCommandInput} for command's `input` shape.
- * @see {@link DeleteParameterCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteParameterCommand extends $Command<DeleteParameterCommandInput, DeleteParameterCommandOutput, SSMClientResolvedConfig> {
     readonly input: DeleteParameterCommandInput;
     constructor(input: DeleteParameterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteParameterCommandInput, DeleteParameterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteParametersCommandInput extends DeleteParametersRequest {
 }
 export interface DeleteParametersCommandOutput extends DeleteParametersResult, __MetadataBearer {
 }
-/**
- * <p>Delete a list of parameters. After deleting a parameter, wait for at least 30 seconds to
- *    create a parameter with the same name.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, DeleteParametersCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, DeleteParametersCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new DeleteParametersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteParametersCommandInput} for command's `input` shape.
- * @see {@link DeleteParametersCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteParametersCommand extends $Command<DeleteParametersCommandInput, DeleteParametersCommandOutput, SSMClientResolvedConfig> {
     readonly input: DeleteParametersCommandInput;
     constructor(input: DeleteParametersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteParametersCommandInput, DeleteParametersCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface DeleteResourceDataSyncCommandInput extends DeleteResourceDataSy
 }
 export interface DeleteResourceDataSyncCommandOutput extends DeleteResourceDataSyncResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a resource data sync configuration. After the configuration is deleted, changes to
- *    data on managed instances are no longer synced to or from the target. Deleting a sync
- *    configuration doesn't delete data.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, DeleteResourceDataSyncCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, DeleteResourceDataSyncCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new DeleteResourceDataSyncCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteResourceDataSyncCommandInput} for command's `input` shape.
- * @see {@link DeleteResourceDataSyncCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteResourceDataSyncCommand extends $Command<DeleteResourceDataSyncCommandInput, DeleteResourceDataSyncCommandOutput, SSMClientResolvedConfig> {
     readonly input: DeleteResourceDataSyncCommandInput;
     constructor(input: DeleteResourceDataSyncCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteResourceDataSyncCommandInput, DeleteResourceDataSyncCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeregisterManagedInstanceCommandInput extends DeregisterManaged
 }
 export interface DeregisterManagedInstanceCommandOutput extends DeregisterManagedInstanceResult, __MetadataBearer {
 }
-/**
- * <p>Removes the server or virtual machine from the list of registered servers. You can
- *    reregister the instance again at any time. If you don't plan to use Run Command on the server, we
- *    suggest uninstalling SSM Agent first.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, DeregisterManagedInstanceCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, DeregisterManagedInstanceCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new DeregisterManagedInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeregisterManagedInstanceCommandInput} for command's `input` shape.
- * @see {@link DeregisterManagedInstanceCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeregisterManagedInstanceCommand extends $Command<DeregisterManagedInstanceCommandInput, DeregisterManagedInstanceCommandOutput, SSMClientResolvedConfig> {
     readonly input: DeregisterManagedInstanceCommandInput;
     constructor(input: DeregisterManagedInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterManagedInstanceCommandInput, DeregisterManagedInstanceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,32 +6,11 @@ export interface DescribeActivationsCommandInput extends DescribeActivationsRequ
 }
 export interface DescribeActivationsCommandOutput extends DescribeActivationsResult, __MetadataBearer {
 }
-/**
- * <p>Describes details about the activation, such as the date and time the activation was
- *    created, its expiration date, the Identity and Access Management (IAM) role assigned to
- *    the instances in the activation, and the number of instances registered by using this
- *    activation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, DescribeActivationsCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, DescribeActivationsCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new DescribeActivationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeActivationsCommandInput} for command's `input` shape.
- * @see {@link DescribeActivationsCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeActivationsCommand extends $Command<DescribeActivationsCommandInput, DescribeActivationsCommandOutput, SSMClientResolvedConfig> {
     readonly input: DescribeActivationsCommandInput;
     constructor(input: DescribeActivationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeActivationsCommandInput, DescribeActivationsCommandOutput>;
     private serialize;
     private deserialize;