@aws-sdk/client-ssm 3.35.0 → 3.38.0

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

@@ -6,30 +6,11 @@ export interface GetConnectionStatusCommandInput extends GetConnectionStatusRequ
 }
 export interface GetConnectionStatusCommandOutput extends GetConnectionStatusResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves the Session Manager connection status for an instance to determine whether it is running and
- *    ready to receive Session Manager connections.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, GetConnectionStatusCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, GetConnectionStatusCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new GetConnectionStatusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetConnectionStatusCommandInput} for command's `input` shape.
- * @see {@link GetConnectionStatusCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetConnectionStatusCommand extends $Command<GetConnectionStatusCommandInput, GetConnectionStatusCommandOutput, SSMClientResolvedConfig> {
     readonly input: GetConnectionStatusCommandInput;
     constructor(input: GetConnectionStatusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConnectionStatusCommandInput, GetConnectionStatusCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetDefaultPatchBaselineCommandInput extends GetDefaultPatchBase
 }
 export interface GetDefaultPatchBaselineCommandOutput extends GetDefaultPatchBaselineResult, __MetadataBearer {
 }
-/**
- * <p>Retrieves the default patch baseline. Amazon Web Services Systems Manager supports creating multiple default patch
- *    baselines. For example, you can create a default patch baseline for each operating system.</p>
- *          <p>If you don't specify an operating system value, the default patch baseline for Windows is
- *    returned.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, GetDefaultPatchBaselineCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, GetDefaultPatchBaselineCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new GetDefaultPatchBaselineCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDefaultPatchBaselineCommandInput} for command's `input` shape.
- * @see {@link GetDefaultPatchBaselineCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDefaultPatchBaselineCommand extends $Command<GetDefaultPatchBaselineCommandInput, GetDefaultPatchBaselineCommandOutput, SSMClientResolvedConfig> {
     readonly input: GetDefaultPatchBaselineCommandInput;
     constructor(input: GetDefaultPatchBaselineCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDefaultPatchBaselineCommandInput, GetDefaultPatchBaselineCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface GetDeployablePatchSnapshotForInstanceCommandInput extends GetDe
 }
 export interface GetDeployablePatchSnapshotForInstanceCommandOutput extends GetDeployablePatchSnapshotForInstanceResult, __MetadataBearer {
 }
-/**
- * <p>Retrieves the current snapshot for the patch baseline the instance uses. This API is
- *    primarily used by the <code>AWS-RunPatchBaseline</code> Systems Manager document (SSM document).</p>
- *          <note>
- *             <p>If you run the command locally, such as with the Command Line Interface (CLI), the system attempts to use your local Amazon Web Services credentials and the operation fails. To avoid
- *     this, you can run the command in the Amazon Web Services Systems Manager console. Use Run Command, a capability of
- *     Amazon Web Services Systems Manager, with an SSM document that enables you to target an instance with a script or command.
- *     For example, run the command using the <code>AWS-RunShellScript</code> document or the
- *      <code>AWS-RunPowerShellScript</code> document.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, GetDeployablePatchSnapshotForInstanceCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, GetDeployablePatchSnapshotForInstanceCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new GetDeployablePatchSnapshotForInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDeployablePatchSnapshotForInstanceCommandInput} for command's `input` shape.
- * @see {@link GetDeployablePatchSnapshotForInstanceCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDeployablePatchSnapshotForInstanceCommand extends $Command<GetDeployablePatchSnapshotForInstanceCommandInput, GetDeployablePatchSnapshotForInstanceCommandOutput, SSMClientResolvedConfig> {
     readonly input: GetDeployablePatchSnapshotForInstanceCommandInput;
     constructor(input: GetDeployablePatchSnapshotForInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeployablePatchSnapshotForInstanceCommandInput, GetDeployablePatchSnapshotForInstanceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -7,30 +7,11 @@ export interface GetInventoryCommandInput extends GetInventoryRequest {
 }
 export interface GetInventoryCommandOutput extends GetInventoryResult, __MetadataBearer {
 }
-/**
- * <p>Query inventory information. This includes instance status, such as <code>Stopped</code> or
- *     <code>Terminated</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, GetInventoryCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, GetInventoryCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new GetInventoryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetInventoryCommandInput} for command's `input` shape.
- * @see {@link GetInventoryCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetInventoryCommand extends $Command<GetInventoryCommandInput, GetInventoryCommandOutput, SSMClientResolvedConfig> {
     readonly input: GetInventoryCommandInput;
     constructor(input: GetInventoryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetInventoryCommandInput, GetInventoryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetInventorySchemaCommandInput extends GetInventorySchemaReques
 }
 export interface GetInventorySchemaCommandOutput extends GetInventorySchemaResult, __MetadataBearer {
 }
-/**
- * <p>Return a list of inventory type names for the account, or return a list of attribute names
- *    for a specific Inventory item type.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, GetInventorySchemaCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, GetInventorySchemaCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new GetInventorySchemaCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetInventorySchemaCommandInput} for command's `input` shape.
- * @see {@link GetInventorySchemaCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetInventorySchemaCommand extends $Command<GetInventorySchemaCommandInput, GetInventorySchemaCommandOutput, SSMClientResolvedConfig> {
     readonly input: GetInventorySchemaCommandInput;
     constructor(input: GetInventorySchemaCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetInventorySchemaCommandInput, GetInventorySchemaCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

@@ -6,35 +6,11 @@ export interface GetMaintenanceWindowTaskCommandInput extends GetMaintenanceWind
 }
 export interface GetMaintenanceWindowTaskCommandOutput extends GetMaintenanceWindowTaskResult, __MetadataBearer {
 }
-/**
- * <p>Lists the tasks in a maintenance window.</p>
- *          <note>
- *             <p>For maintenance window tasks without a specified target, you can't supply values for
- *      <code>--max-errors</code> and <code>--max-concurrency</code>. Instead, the system inserts a
- *     placeholder value of <code>1</code>, which may be reported in the response to this command.
- *     These values don't affect the running of your task and can be ignored.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, GetMaintenanceWindowTaskCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, GetMaintenanceWindowTaskCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new GetMaintenanceWindowTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetMaintenanceWindowTaskCommandInput} for command's `input` shape.
- * @see {@link GetMaintenanceWindowTaskCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetMaintenanceWindowTaskCommand extends $Command<GetMaintenanceWindowTaskCommandInput, GetMaintenanceWindowTaskCommandOutput, SSMClientResolvedConfig> {
     readonly input: GetMaintenanceWindowTaskCommandInput;
     constructor(input: GetMaintenanceWindowTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMaintenanceWindowTaskCommandInput, GetMaintenanceWindowTaskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface GetOpsItemCommandInput extends GetOpsItemRequest {
 }
 export interface GetOpsItemCommandOutput extends GetOpsItemResponse, __MetadataBearer {
 }
-/**
- * <p>Get information about an OpsItem by using the ID. You must have permission in Identity and Access Management (IAM) to view information about an OpsItem. For more information,
- *    see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter-getting-started.html">Getting started with
- *     OpsCenter</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
- *          <p>Operations engineers and IT professionals use Amazon Web Services Systems Manager OpsCenter to view, investigate, and
- *    remediate operational issues impacting the performance and health of their Amazon Web Services resources. For
- *    more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter.html">OpsCenter</a> in the
- *     <i>Amazon Web Services Systems Manager User Guide</i>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, GetOpsItemCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, GetOpsItemCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new GetOpsItemCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetOpsItemCommandInput} for command's `input` shape.
- * @see {@link GetOpsItemCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetOpsItemCommand extends $Command<GetOpsItemCommandInput, GetOpsItemCommandOutput, SSMClientResolvedConfig> {
     readonly input: GetOpsItemCommandInput;
     constructor(input: GetOpsItemCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetOpsItemCommandInput, GetOpsItemCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -7,32 +7,11 @@ export interface GetOpsSummaryCommandInput extends GetOpsSummaryRequest {
 }
 export interface GetOpsSummaryCommandOutput extends GetOpsSummaryResult, __MetadataBearer {
 }
-/**
- * <p>View a summary of operations metadata (OpsData) based on specified filters and aggregators.
- *    OpsData can include information about Amazon Web Services Systems Manager OpsCenter operational workitems (OpsItems) as
- *    well as information about any Amazon Web Services resource or service configured to report OpsData to Amazon Web Services Systems Manager
- *    Explorer. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, GetOpsSummaryCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, GetOpsSummaryCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new GetOpsSummaryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetOpsSummaryCommandInput} for command's `input` shape.
- * @see {@link GetOpsSummaryCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetOpsSummaryCommand extends $Command<GetOpsSummaryCommandInput, GetOpsSummaryCommandOutput, SSMClientResolvedConfig> {
     readonly input: GetOpsSummaryCommandInput;
     constructor(input: GetOpsSummaryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetOpsSummaryCommandInput, GetOpsSummaryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetParameterCommandInput extends GetParameterRequest {
 }
 export interface GetParameterCommandOutput extends GetParameterResult, __MetadataBearer {
 }
-/**
- * <p>Get information about a single parameter by specifying the parameter name.</p>
- *          <note>
- *             <p>To get information about more than one parameter at a time, use the <a>GetParameters</a> operation.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, GetParameterCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, GetParameterCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new GetParameterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetParameterCommandInput} for command's `input` shape.
- * @see {@link GetParameterCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetParameterCommand extends $Command<GetParameterCommandInput, GetParameterCommandOutput, SSMClientResolvedConfig> {
     readonly input: GetParameterCommandInput;
     constructor(input: GetParameterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetParameterCommandInput, GetParameterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface GetParameterHistoryCommandInput extends GetParameterHistoryRequ
 }
 export interface GetParameterHistoryCommandOutput extends GetParameterHistoryResult, __MetadataBearer {
 }
-/**
- * <p>Retrieves the history of all changes to a parameter.</p>
- *          <important>
- *             <p>If you change the KMS key alias for the KMS key used to encrypt a parameter, then you must
- *     also update the key alias the parameter uses to reference KMS. Otherwise,
- *      <code>GetParameterHistory</code> retrieves whatever the original key alias was
- *     referencing.</p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, GetParameterHistoryCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, GetParameterHistoryCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new GetParameterHistoryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetParameterHistoryCommandInput} for command's `input` shape.
- * @see {@link GetParameterHistoryCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetParameterHistoryCommand extends $Command<GetParameterHistoryCommandInput, GetParameterHistoryCommandOutput, SSMClientResolvedConfig> {
     readonly input: GetParameterHistoryCommandInput;
     constructor(input: GetParameterHistoryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetParameterHistoryCommandInput, GetParameterHistoryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface GetParametersByPathCommandInput extends GetParametersByPathRequ
 }
 export interface GetParametersByPathCommandOutput extends GetParametersByPathResult, __MetadataBearer {
 }
-/**
- * <p>Retrieve information about one or more parameters in a specific hierarchy. </p>
- *          <p>Request results are returned on a best-effort basis. If you specify <code>MaxResults</code>
- *    in the request, the response includes information up to the limit specified. The number of items
- *    returned, however, can be between zero and the value of <code>MaxResults</code>. If the service
- *    reaches an internal limit while processing the results, it stops the operation and returns the
- *    matching values up to that point and a <code>NextToken</code>. You can specify the
- *     <code>NextToken</code> in a subsequent call to get the next set of results.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, GetParametersByPathCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, GetParametersByPathCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new GetParametersByPathCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetParametersByPathCommandInput} for command's `input` shape.
- * @see {@link GetParametersByPathCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetParametersByPathCommand extends $Command<GetParametersByPathCommandInput, GetParametersByPathCommandOutput, SSMClientResolvedConfig> {
     readonly input: GetParametersByPathCommandInput;
     constructor(input: GetParametersByPathCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetParametersByPathCommandInput, GetParametersByPathCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface GetParametersCommandInput extends GetParametersRequest {
 }
 export interface GetParametersCommandOutput extends GetParametersResult, __MetadataBearer {
 }
-/**
- * <p>Get information about one or more parameters by specifying multiple parameter names.</p>
- *          <note>
- *             <p>To get information about a single parameter, you can use the <a>GetParameter</a>
- *     operation instead.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SSMClient, GetParametersCommand } from "@aws-sdk/client-ssm"; // ES Modules import
- * // const { SSMClient, GetParametersCommand } = require("@aws-sdk/client-ssm"); // CommonJS import
- * const client = new SSMClient(config);
- * const command = new GetParametersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetParametersCommandInput} for command's `input` shape.
- * @see {@link GetParametersCommandOutput} for command's `response` shape.
- * @see {@link SSMClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetParametersCommand extends $Command<GetParametersCommandInput, GetParametersCommandOutput, SSMClientResolvedConfig> {
     readonly input: GetParametersCommandInput;
     constructor(input: GetParametersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SSMClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetParametersCommandInput, GetParametersCommandOutput>;
     private serialize;
     private deserialize;