@aws-sdk/client-cloudwatch 3.36.0 → 3.39.0

package/dist-types/ts3.4/CloudWatchClient.d.ts

@@ -45,138 +45,59 @@ import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./command
 export declare type ServiceInputTypes = DeleteAlarmsCommandInput | DeleteAnomalyDetectorCommandInput | DeleteDashboardsCommandInput | DeleteInsightRulesCommandInput | DeleteMetricStreamCommandInput | DescribeAlarmHistoryCommandInput | DescribeAlarmsCommandInput | DescribeAlarmsForMetricCommandInput | DescribeAnomalyDetectorsCommandInput | DescribeInsightRulesCommandInput | DisableAlarmActionsCommandInput | DisableInsightRulesCommandInput | EnableAlarmActionsCommandInput | EnableInsightRulesCommandInput | GetDashboardCommandInput | GetInsightRuleReportCommandInput | GetMetricDataCommandInput | GetMetricStatisticsCommandInput | GetMetricStreamCommandInput | GetMetricWidgetImageCommandInput | ListDashboardsCommandInput | ListMetricStreamsCommandInput | ListMetricsCommandInput | ListTagsForResourceCommandInput | PutAnomalyDetectorCommandInput | PutCompositeAlarmCommandInput | PutDashboardCommandInput | PutInsightRuleCommandInput | PutMetricAlarmCommandInput | PutMetricDataCommandInput | PutMetricStreamCommandInput | SetAlarmStateCommandInput | StartMetricStreamsCommandInput | StopMetricStreamsCommandInput | TagResourceCommandInput | UntagResourceCommandInput;
 export declare type ServiceOutputTypes = DeleteAlarmsCommandOutput | DeleteAnomalyDetectorCommandOutput | DeleteDashboardsCommandOutput | DeleteInsightRulesCommandOutput | DeleteMetricStreamCommandOutput | DescribeAlarmHistoryCommandOutput | DescribeAlarmsCommandOutput | DescribeAlarmsForMetricCommandOutput | DescribeAnomalyDetectorsCommandOutput | DescribeInsightRulesCommandOutput | DisableAlarmActionsCommandOutput | DisableInsightRulesCommandOutput | EnableAlarmActionsCommandOutput | EnableInsightRulesCommandOutput | GetDashboardCommandOutput | GetInsightRuleReportCommandOutput | GetMetricDataCommandOutput | GetMetricStatisticsCommandOutput | GetMetricStreamCommandOutput | GetMetricWidgetImageCommandOutput | ListDashboardsCommandOutput | ListMetricStreamsCommandOutput | ListMetricsCommandOutput | ListTagsForResourceCommandOutput | PutAnomalyDetectorCommandOutput | PutCompositeAlarmCommandOutput | PutDashboardCommandOutput | PutInsightRuleCommandOutput | PutMetricAlarmCommandOutput | PutMetricDataCommandOutput | PutMetricStreamCommandOutput | SetAlarmStateCommandOutput | StartMetricStreamsCommandOutput | StopMetricStreamsCommandOutput | TagResourceCommandOutput | UntagResourceCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type CloudWatchClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of CloudWatchClient class constructor that set the region, credentials and other options.
- */
+
 export interface CloudWatchClientConfig extends CloudWatchClientConfigType {
 }
 declare type CloudWatchClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of CloudWatchClient class. This is resolved and normalized from the {@link CloudWatchClientConfig | constructor configuration interface}.
- */
+
 export interface CloudWatchClientResolvedConfig extends CloudWatchClientResolvedConfigType {
 }
-/**
- * <p>Amazon CloudWatch monitors your Amazon Web Services (Amazon Web Services) resources and the
- * 			applications you run on Amazon Web Services in real time. You can use CloudWatch to collect and track
- * 			metrics, which are the variables you want to measure for your resources and
- * 			applications.</p>
- *
- * 		       <p>CloudWatch alarms send notifications or automatically change the resources you are monitoring based on rules
- * 			that you define. For example, you can monitor the CPU usage and disk reads and writes of your Amazon EC2
- * 			instances. Then, use this data to determine whether you should launch
- * 			additional instances to handle increased load. You can also use this data to stop
- * 			under-used instances to save
- * 			money.</p>
- *
- * 		       <p>In addition to monitoring the built-in metrics that come with Amazon Web Services, you can monitor
- * 			your own custom metrics. With CloudWatch, you gain system-wide visibility into resource
- * 			utilization, application performance, and operational health.</p>
- */
+
 export declare class CloudWatchClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, CloudWatchClientResolvedConfig> {
-    /**
-     * The resolved configuration of CloudWatchClient class. This is resolved and normalized from the {@link CloudWatchClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: CloudWatchClientResolvedConfig;
     constructor(configuration: CloudWatchClientConfig);
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
+    
     destroy(): void;
 }
 export {};

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

@@ -6,44 +6,11 @@ export interface DeleteAlarmsCommandInput extends DeleteAlarmsInput {
 }
 export interface DeleteAlarmsCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified alarms. You can delete up to 100 alarms in one operation. However, this total can include no more
- * 			than one composite alarm. For example, you could delete 99 metric alarms and one composite alarms with one operation, but you can't
- * 			delete two composite alarms with one operation.</p>
- * 		       <p>
- * 			In the event of an error, no alarms are
- * 			deleted.</p>
- * 		       <note>
- *             <p>It is possible to create a loop or cycle of composite alarms, where composite alarm A depends on composite alarm B, and
- * 			composite alarm B also depends on composite alarm A. In this scenario, you can't delete any composite alarm that is part of the cycle
- * 			because there is always still a composite alarm that depends on that alarm that you want to delete.</p>
- * 			         <p>To get out of such a situation, you must
- * 				break the cycle by changing the rule of one of the composite alarms in the cycle to remove a dependency that creates the cycle. The simplest
- * 				change to make to break a cycle is to change the <code>AlarmRule</code> of one of the alarms to <code>False</code>. </p>
- * 			         <p>Additionally, the evaluation of composite alarms stops if CloudWatch detects a cycle in the evaluation path.
- * 			</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, DeleteAlarmsCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, DeleteAlarmsCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new DeleteAlarmsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteAlarmsCommandInput} for command's `input` shape.
- * @see {@link DeleteAlarmsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteAlarmsCommand extends $Command<DeleteAlarmsCommandInput, DeleteAlarmsCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: DeleteAlarmsCommandInput;
     constructor(input: DeleteAlarmsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAlarmsCommandInput, DeleteAlarmsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteAnomalyDetectorCommandInput extends DeleteAnomalyDetector
 }
 export interface DeleteAnomalyDetectorCommandOutput extends DeleteAnomalyDetectorOutput, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified anomaly detection model from your account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, DeleteAnomalyDetectorCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, DeleteAnomalyDetectorCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new DeleteAnomalyDetectorCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteAnomalyDetectorCommandInput} for command's `input` shape.
- * @see {@link DeleteAnomalyDetectorCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteAnomalyDetectorCommand extends $Command<DeleteAnomalyDetectorCommandInput, DeleteAnomalyDetectorCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: DeleteAnomalyDetectorCommandInput;
     constructor(input: DeleteAnomalyDetectorCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAnomalyDetectorCommandInput, DeleteAnomalyDetectorCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeleteDashboardsCommandInput extends DeleteDashboardsInput {
 }
 export interface DeleteDashboardsCommandOutput extends DeleteDashboardsOutput, __MetadataBearer {
 }
-/**
- * <p>Deletes all dashboards that you specify. You
- * 			can specify up to 100 dashboards to delete. If there is an error during this call, no dashboards are
- * 			deleted.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, DeleteDashboardsCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, DeleteDashboardsCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new DeleteDashboardsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDashboardsCommandInput} for command's `input` shape.
- * @see {@link DeleteDashboardsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDashboardsCommand extends $Command<DeleteDashboardsCommandInput, DeleteDashboardsCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: DeleteDashboardsCommandInput;
     constructor(input: DeleteDashboardsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDashboardsCommandInput, DeleteDashboardsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteInsightRulesCommandInput extends DeleteInsightRulesInput
 }
 export interface DeleteInsightRulesCommandOutput extends DeleteInsightRulesOutput, __MetadataBearer {
 }
-/**
- * <p>Permanently deletes the specified Contributor Insights rules.</p>
- * 		       <p>If you create a rule, delete it, and then re-create it with the same name, historical data from the first time
- * 			the rule was created might
- * 			not be available.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, DeleteInsightRulesCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, DeleteInsightRulesCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new DeleteInsightRulesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteInsightRulesCommandInput} for command's `input` shape.
- * @see {@link DeleteInsightRulesCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteInsightRulesCommand extends $Command<DeleteInsightRulesCommandInput, DeleteInsightRulesCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: DeleteInsightRulesCommandInput;
     constructor(input: DeleteInsightRulesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteInsightRulesCommandInput, DeleteInsightRulesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteMetricStreamCommandInput extends DeleteMetricStreamInput
 }
 export interface DeleteMetricStreamCommandOutput extends DeleteMetricStreamOutput, __MetadataBearer {
 }
-/**
- * <p>Permanently deletes the metric stream that you specify.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, DeleteMetricStreamCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, DeleteMetricStreamCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new DeleteMetricStreamCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteMetricStreamCommandInput} for command's `input` shape.
- * @see {@link DeleteMetricStreamCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteMetricStreamCommand extends $Command<DeleteMetricStreamCommandInput, DeleteMetricStreamCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: DeleteMetricStreamCommandInput;
     constructor(input: DeleteMetricStreamCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteMetricStreamCommandInput, DeleteMetricStreamCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeAlarmHistoryCommandInput extends DescribeAlarmHistoryIn
 }
 export interface DescribeAlarmHistoryCommandOutput extends DescribeAlarmHistoryOutput, __MetadataBearer {
 }
-/**
- * <p>Retrieves the history for the specified alarm. You can filter the results by date range or item type.
- * 			If an alarm name is not specified, the histories for either all metric alarms or all composite alarms are returned.</p>
- * 		       <p>CloudWatch retains the history of an alarm even if you delete the alarm.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, DescribeAlarmHistoryCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, DescribeAlarmHistoryCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new DescribeAlarmHistoryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAlarmHistoryCommandInput} for command's `input` shape.
- * @see {@link DescribeAlarmHistoryCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAlarmHistoryCommand extends $Command<DescribeAlarmHistoryCommandInput, DescribeAlarmHistoryCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: DescribeAlarmHistoryCommandInput;
     constructor(input: DescribeAlarmHistoryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAlarmHistoryCommandInput, DescribeAlarmHistoryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeAlarmsCommandInput extends DescribeAlarmsInput {
 }
 export interface DescribeAlarmsCommandOutput extends DescribeAlarmsOutput, __MetadataBearer {
 }
-/**
- * <p>Retrieves the specified alarms. You can filter the results by specifying a prefix for the alarm
- * 			name, the alarm state, or a prefix for any action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, DescribeAlarmsCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, DescribeAlarmsCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new DescribeAlarmsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAlarmsCommandInput} for command's `input` shape.
- * @see {@link DescribeAlarmsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAlarmsCommand extends $Command<DescribeAlarmsCommandInput, DescribeAlarmsCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: DescribeAlarmsCommandInput;
     constructor(input: DescribeAlarmsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAlarmsCommandInput, DescribeAlarmsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DescribeAlarmsForMetricCommandInput extends DescribeAlarmsForMe
 }
 export interface DescribeAlarmsForMetricCommandOutput extends DescribeAlarmsForMetricOutput, __MetadataBearer {
 }
-/**
- * <p>Retrieves the alarms for the specified metric. To
- * 			filter the results, specify a statistic, period, or unit.</p>
- * 		       <p>This operation retrieves only standard alarms that are based on
- * 		the specified metric. It does not return alarms based on math expressions that
- * 		use the specified metric, or composite alarms that use the specified metric.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, DescribeAlarmsForMetricCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, DescribeAlarmsForMetricCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new DescribeAlarmsForMetricCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAlarmsForMetricCommandInput} for command's `input` shape.
- * @see {@link DescribeAlarmsForMetricCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAlarmsForMetricCommand extends $Command<DescribeAlarmsForMetricCommandInput, DescribeAlarmsForMetricCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: DescribeAlarmsForMetricCommandInput;
     constructor(input: DescribeAlarmsForMetricCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAlarmsForMetricCommandInput, DescribeAlarmsForMetricCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeAnomalyDetectorsCommandInput extends DescribeAnomalyDet
 }
 export interface DescribeAnomalyDetectorsCommandOutput extends DescribeAnomalyDetectorsOutput, __MetadataBearer {
 }
-/**
- * <p>Lists the anomaly detection models that you have created in your account. You can list all
- * 			models in your account or filter the results to only the models that are related to a
- * 			certain namespace, metric name, or metric dimension.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, DescribeAnomalyDetectorsCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, DescribeAnomalyDetectorsCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new DescribeAnomalyDetectorsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAnomalyDetectorsCommandInput} for command's `input` shape.
- * @see {@link DescribeAnomalyDetectorsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAnomalyDetectorsCommand extends $Command<DescribeAnomalyDetectorsCommandInput, DescribeAnomalyDetectorsCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: DescribeAnomalyDetectorsCommandInput;
     constructor(input: DescribeAnomalyDetectorsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAnomalyDetectorsCommandInput, DescribeAnomalyDetectorsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribeInsightRulesCommandInput extends DescribeInsightRulesIn
 }
 export interface DescribeInsightRulesCommandOutput extends DescribeInsightRulesOutput, __MetadataBearer {
 }
-/**
- * <p>Returns a list of all the Contributor Insights rules in your account.</p>
- *
- * 		       <p>For more information about Contributor Insights, see
- * 		<a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContributorInsights.html">Using Contributor Insights to Analyze High-Cardinality Data</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, DescribeInsightRulesCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, DescribeInsightRulesCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new DescribeInsightRulesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeInsightRulesCommandInput} for command's `input` shape.
- * @see {@link DescribeInsightRulesCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeInsightRulesCommand extends $Command<DescribeInsightRulesCommandInput, DescribeInsightRulesCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: DescribeInsightRulesCommandInput;
     constructor(input: DescribeInsightRulesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeInsightRulesCommandInput, DescribeInsightRulesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DisableAlarmActionsCommandInput extends DisableAlarmActionsInpu
 }
 export interface DisableAlarmActionsCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Disables the actions for the specified alarms. When an alarm's actions are disabled, the
- * 			alarm actions do not execute when the alarm state changes.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, DisableAlarmActionsCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, DisableAlarmActionsCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new DisableAlarmActionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableAlarmActionsCommandInput} for command's `input` shape.
- * @see {@link DisableAlarmActionsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisableAlarmActionsCommand extends $Command<DisableAlarmActionsCommandInput, DisableAlarmActionsCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: DisableAlarmActionsCommandInput;
     constructor(input: DisableAlarmActionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableAlarmActionsCommandInput, DisableAlarmActionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DisableInsightRulesCommandInput extends DisableInsightRulesInpu
 }
 export interface DisableInsightRulesCommandOutput extends DisableInsightRulesOutput, __MetadataBearer {
 }
-/**
- * <p>Disables the specified Contributor Insights rules. When rules are disabled, they do not analyze log groups and do
- * 		not incur costs.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, DisableInsightRulesCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, DisableInsightRulesCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new DisableInsightRulesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableInsightRulesCommandInput} for command's `input` shape.
- * @see {@link DisableInsightRulesCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisableInsightRulesCommand extends $Command<DisableInsightRulesCommandInput, DisableInsightRulesCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: DisableInsightRulesCommandInput;
     constructor(input: DisableInsightRulesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableInsightRulesCommandInput, DisableInsightRulesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface EnableAlarmActionsCommandInput extends EnableAlarmActionsInput
 }
 export interface EnableAlarmActionsCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Enables the actions for the specified alarms.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, EnableAlarmActionsCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, EnableAlarmActionsCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new EnableAlarmActionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableAlarmActionsCommandInput} for command's `input` shape.
- * @see {@link EnableAlarmActionsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableAlarmActionsCommand extends $Command<EnableAlarmActionsCommandInput, EnableAlarmActionsCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: EnableAlarmActionsCommandInput;
     constructor(input: EnableAlarmActionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableAlarmActionsCommandInput, EnableAlarmActionsCommandOutput>;
     private serialize;
     private deserialize;