@aws-sdk/client-cloudwatch 3.36.0 → 3.39.0

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

@@ -6,29 +6,11 @@ export interface EnableInsightRulesCommandInput extends EnableInsightRulesInput
 }
 export interface EnableInsightRulesCommandOutput extends EnableInsightRulesOutput, __MetadataBearer {
 }
-/**
- * <p>Enables the specified Contributor Insights rules. When rules are enabled, they immediately begin analyzing log data.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, EnableInsightRulesCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, EnableInsightRulesCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new EnableInsightRulesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableInsightRulesCommandInput} for command's `input` shape.
- * @see {@link EnableInsightRulesCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableInsightRulesCommand extends $Command<EnableInsightRulesCommandInput, EnableInsightRulesCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: EnableInsightRulesCommandInput;
     constructor(input: EnableInsightRulesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableInsightRulesCommandInput, EnableInsightRulesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetDashboardCommandInput extends GetDashboardInput {
 }
 export interface GetDashboardCommandOutput extends GetDashboardOutput, __MetadataBearer {
 }
-/**
- * <p>Displays the details of the dashboard that you specify.</p>
- * 		       <p>To copy an existing dashboard, use <code>GetDashboard</code>, and then use the data returned
- * 			within <code>DashboardBody</code> as the template for the new dashboard when you call <code>PutDashboard</code> to create
- * 			the copy.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, GetDashboardCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, GetDashboardCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new GetDashboardCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDashboardCommandInput} for command's `input` shape.
- * @see {@link GetDashboardCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDashboardCommand extends $Command<GetDashboardCommandInput, GetDashboardCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: GetDashboardCommandInput;
     constructor(input: GetDashboardCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDashboardCommandInput, GetDashboardCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,65 +6,11 @@ export interface GetInsightRuleReportCommandInput extends GetInsightRuleReportIn
 }
 export interface GetInsightRuleReportCommandOutput extends GetInsightRuleReportOutput, __MetadataBearer {
 }
-/**
- * <p>This operation returns the time series data collected by a Contributor Insights rule. The data includes the identity and number of
- * 		contributors to the log group.</p>
- * 		       <p>You can also optionally return one or more statistics about each data point in the time series. These statistics can include the following:</p>
- * 		       <ul>
- *             <li>
- * 				           <p>
- *                   <code>UniqueContributors</code> -- the number of unique contributors for each data point.</p>
- * 			         </li>
- *             <li>
- * 				           <p>
- *                   <code>MaxContributorValue</code> -- the value of the top contributor for each data point. The identity of the
- * 					contributor might change for each data point in the graph.</p>
- * 				           <p>If this rule aggregates by COUNT, the top contributor for each data point is the contributor with the
- * 					most occurrences in that period. If the rule aggregates by SUM, the top contributor is the contributor with the highest sum in the log field specified
- * 					by the rule's <code>Value</code>, during that period.</p>
- * 			         </li>
- *             <li>
- * 				           <p>
- *                   <code>SampleCount</code> -- the number of data points matched by the rule.</p>
- * 			         </li>
- *             <li>
- * 				           <p>
- *                   <code>Sum</code> -- the sum of the values from all contributors during the time period represented by that data point.</p>
- * 			         </li>
- *             <li>
- * 				           <p>
- *                   <code>Minimum</code> -- the minimum value from a single observation during the time period represented by that data point.</p>
- * 			         </li>
- *             <li>
- * 				           <p>
- *                   <code>Maximum</code> -- the maximum value from a single observation during the time period represented by that data point.</p>
- * 			         </li>
- *             <li>
- * 				           <p>
- *                   <code>Average</code> -- the average value from all contributors during the time period represented by that data point.</p>
- * 			         </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, GetInsightRuleReportCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, GetInsightRuleReportCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new GetInsightRuleReportCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetInsightRuleReportCommandInput} for command's `input` shape.
- * @see {@link GetInsightRuleReportCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetInsightRuleReportCommand extends $Command<GetInsightRuleReportCommandInput, GetInsightRuleReportCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: GetInsightRuleReportCommandInput;
     constructor(input: GetInsightRuleReportCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetInsightRuleReportCommandInput, GetInsightRuleReportCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,64 +6,11 @@ export interface GetMetricDataCommandInput extends GetMetricDataInput {
 }
 export interface GetMetricDataCommandOutput extends GetMetricDataOutput, __MetadataBearer {
 }
-/**
- * <p>You can use the <code>GetMetricData</code> API to retrieve as many as 500 different
- * 			metrics in a single request, with a total of as many as 100,800 data points. You can also
- * 			optionally perform math expressions on the values of the returned statistics, to create
- * 			new time series that represent new insights into your data. For example, using Lambda
- * 			metrics, you could divide the Errors metric by the Invocations metric to get an error
- * 			rate time series. For more information about metric math expressions, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/using-metric-math.html#metric-math-syntax">Metric Math Syntax and Functions</a> in the <i>Amazon CloudWatch User
- * 				Guide</i>.</p>
- *
- * 		       <p>Calls to the <code>GetMetricData</code> API have a different pricing structure than
- * 			calls to <code>GetMetricStatistics</code>. For more information about pricing, see
- * 			<a href="https://aws.amazon.com/cloudwatch/pricing/">Amazon CloudWatch Pricing</a>.</p>
- *
- * 		       <p>Amazon CloudWatch retains metric data as follows:</p>
- * 		       <ul>
- *             <li>
- *                <p>Data points with a period of less than 60 seconds are available for 3 hours. These data points are high-resolution
- * 				metrics and are available only for custom metrics that have been defined with a <code>StorageResolution</code> of 1.</p>
- *             </li>
- *             <li>
- *                <p>Data points with a period of 60 seconds (1-minute) are available for 15 days.</p>
- *             </li>
- *             <li>
- *                <p>Data points with a period of 300 seconds (5-minute) are available for 63 days.</p>
- *             </li>
- *             <li>
- *                <p>Data points with a period of 3600 seconds (1 hour) are available for 455 days (15 months).</p>
- *             </li>
- *          </ul>
- * 		       <p>Data points that are initially published with a shorter period are aggregated together for long-term storage. For example, if you collect
- * 			data using a period of 1 minute, the data remains available for 15 days with 1-minute resolution. After 15 days, this data is still available,
- * 			but is aggregated and retrievable only with a resolution of 5 minutes. After 63 days, the data is further aggregated and is available with
- * 			a resolution of 1 hour.</p>
- *
- * 		       <p>If you omit <code>Unit</code> in your request, all data that was collected with any unit is returned, along with the corresponding units that were specified
- * 			when the data was reported to CloudWatch. If you specify a unit, the operation returns only data that was collected with that unit specified.
- * 			If you specify a unit that does not match the data collected, the results of the operation are null. CloudWatch does not perform unit conversions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, GetMetricDataCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, GetMetricDataCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new GetMetricDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetMetricDataCommandInput} for command's `input` shape.
- * @see {@link GetMetricDataCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetMetricDataCommand extends $Command<GetMetricDataCommandInput, GetMetricDataCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: GetMetricDataCommandInput;
     constructor(input: GetMetricDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMetricDataCommandInput, GetMetricDataCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,80 +6,11 @@ export interface GetMetricStatisticsCommandInput extends GetMetricStatisticsInpu
 }
 export interface GetMetricStatisticsCommandOutput extends GetMetricStatisticsOutput, __MetadataBearer {
 }
-/**
- * <p>Gets statistics for the specified metric.</p>
- *
- *
- *
- * 		       <p>The maximum number of data points returned from a single call is 1,440. If
- * 			you request more than 1,440 data points, CloudWatch returns an error.
- * 			To reduce the number of data points, you can narrow the specified time range and make
- * 			multiple requests across adjacent time ranges, or you can increase the specified period.
- * 			Data points are not returned in chronological order.</p>
- *
- * 		       <p>CloudWatch aggregates data points based on the length of the period
- * 			that you specify. For example, if you request statistics with a one-hour period,
- * 			CloudWatch aggregates all data points with time stamps that fall within each
- * 			one-hour period. Therefore, the number of values aggregated by CloudWatch is larger than
- * 			the number of data points returned.</p>
- * 		       <p>CloudWatch needs raw data points to calculate percentile statistics. If you publish
- * 			data using a statistic set instead, you can only retrieve
- * 			percentile statistics for this data if one of the following conditions is true:</p>
- * 		       <ul>
- *             <li>
- *                <p>The SampleCount value of the statistic set is 1.</p>
- *             </li>
- *             <li>
- *                <p>The Min and the Max values of the statistic set are equal.</p>
- *             </li>
- *          </ul>
- * 		       <p>Percentile statistics are not available for metrics when any of the metric values are negative numbers.</p>
- * 		       <p>Amazon CloudWatch retains metric data as follows:</p>
- * 		       <ul>
- *             <li>
- *                <p>Data points with a period of less than 60 seconds are available for 3 hours. These data points are high-resolution
- * 				metrics and are available only for custom metrics that have been defined with a <code>StorageResolution</code> of 1.</p>
- *             </li>
- *             <li>
- *                <p>Data points with a period of 60 seconds (1-minute) are available for 15 days.</p>
- *             </li>
- *             <li>
- *                <p>Data points with a period of 300 seconds (5-minute) are available for 63 days.</p>
- *             </li>
- *             <li>
- *                <p>Data points with a period of 3600 seconds (1 hour) are available for 455 days (15 months).</p>
- *             </li>
- *          </ul>
- * 		       <p>Data points that are initially published with a shorter period are aggregated together for long-term storage. For example, if you collect
- * 			data using a period of 1 minute, the data remains available for 15 days with 1-minute resolution. After 15 days, this data is still available,
- * 			but is aggregated and retrievable only with a resolution of 5 minutes. After 63 days, the data is further aggregated and is available with
- * 		a resolution of 1 hour.</p>
- * 		       <p>CloudWatch started retaining 5-minute and 1-hour metric data as of July 9, 2016.</p>
- *
- * 		       <p>For information about metrics and dimensions supported by Amazon Web Services services, see the
- * 			<a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CW_Support_For_AWS.html">Amazon CloudWatch Metrics and Dimensions Reference</a> in the
- * 			<i>Amazon CloudWatch User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, GetMetricStatisticsCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, GetMetricStatisticsCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new GetMetricStatisticsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetMetricStatisticsCommandInput} for command's `input` shape.
- * @see {@link GetMetricStatisticsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetMetricStatisticsCommand extends $Command<GetMetricStatisticsCommandInput, GetMetricStatisticsCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: GetMetricStatisticsCommandInput;
     constructor(input: GetMetricStatisticsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMetricStatisticsCommandInput, GetMetricStatisticsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetMetricStreamCommandInput extends GetMetricStreamInput {
 }
 export interface GetMetricStreamCommandOutput extends GetMetricStreamOutput, __MetadataBearer {
 }
-/**
- * <p>Returns information about 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, GetMetricStreamCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, GetMetricStreamCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new GetMetricStreamCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetMetricStreamCommandInput} for command's `input` shape.
- * @see {@link GetMetricStreamCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetMetricStreamCommand extends $Command<GetMetricStreamCommandInput, GetMetricStreamCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: GetMetricStreamCommandInput;
     constructor(input: GetMetricStreamCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMetricStreamCommandInput, GetMetricStreamCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,46 +6,11 @@ export interface GetMetricWidgetImageCommandInput extends GetMetricWidgetImageIn
 }
 export interface GetMetricWidgetImageCommandOutput extends GetMetricWidgetImageOutput, __MetadataBearer {
 }
-/**
- * <p>You can use the <code>GetMetricWidgetImage</code> API to retrieve a snapshot graph of
- * 			one or more Amazon CloudWatch metrics as a bitmap image. You can then embed this
- * 			image into your services and products, such as wiki pages, reports, and documents.
- * 			You could also retrieve images regularly, such as every minute, and create your own
- * 			custom live dashboard.</p>
- *
- * 		       <p>The graph you retrieve can include all CloudWatch metric graph features, including metric math
- * 		and horizontal and vertical annotations.</p>
- *
- * 		       <p>There is a limit of 20 transactions per second for this API. Each <code>GetMetricWidgetImage</code> action has the following limits:</p>
- * 		       <ul>
- *             <li>
- * 				           <p>As many as 100 metrics in the graph.</p>
- * 			         </li>
- *             <li>
- * 				           <p>Up to 100 KB uncompressed payload.</p>
- * 			         </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, GetMetricWidgetImageCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, GetMetricWidgetImageCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new GetMetricWidgetImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetMetricWidgetImageCommandInput} for command's `input` shape.
- * @see {@link GetMetricWidgetImageCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetMetricWidgetImageCommand extends $Command<GetMetricWidgetImageCommandInput, GetMetricWidgetImageCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: GetMetricWidgetImageCommandInput;
     constructor(input: GetMetricWidgetImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMetricWidgetImageCommandInput, GetMetricWidgetImageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface ListDashboardsCommandInput extends ListDashboardsInput {
 }
 export interface ListDashboardsCommandOutput extends ListDashboardsOutput, __MetadataBearer {
 }
-/**
- * <p>Returns a list of the dashboards for your account. If you include <code>DashboardNamePrefix</code>, only
- * 			those dashboards with names starting with the prefix are listed. Otherwise, all dashboards in your account are
- * 			listed.
- * 	    </p>
- * 		       <p>
- *             <code>ListDashboards</code> returns up to 1000 results on one page. If there
- * 			are more than 1000 dashboards, you can call <code>ListDashboards</code> again and
- * 		include the value you received for <code>NextToken</code> in the first call, to receive
- * 		the next 1000 results.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, ListDashboardsCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, ListDashboardsCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new ListDashboardsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDashboardsCommandInput} for command's `input` shape.
- * @see {@link ListDashboardsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDashboardsCommand extends $Command<ListDashboardsCommandInput, ListDashboardsCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: ListDashboardsCommandInput;
     constructor(input: ListDashboardsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDashboardsCommandInput, ListDashboardsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,42 +6,11 @@ export interface ListMetricsCommandInput extends ListMetricsInput {
 }
 export interface ListMetricsCommandOutput extends ListMetricsOutput, __MetadataBearer {
 }
-/**
- * <p>List the specified metrics. You can use the returned metrics with
- * 			<a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html">GetMetricData</a> or
- * 			<a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html">GetMetricStatistics</a> to obtain statistical data.</p>
- * 		       <p>Up to 500 results are returned for any one call. To retrieve additional results,
- * 			use the returned token with subsequent calls.</p>
- * 		       <p>After you create a metric, allow up to 15 minutes before the metric appears.
- * 			You can see statistics about the metric sooner by using <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html">GetMetricData</a> or
- * 			<a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html">GetMetricStatistics</a>.</p>
- *
- * 	        <p>
- *             <code>ListMetrics</code> doesn't return information about metrics if those metrics haven't
- * 	reported data in the past two weeks. To retrieve those metrics, use
- * 		<a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html">GetMetricData</a> or
- * 		<a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html">GetMetricStatistics</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, ListMetricsCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, ListMetricsCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new ListMetricsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListMetricsCommandInput} for command's `input` shape.
- * @see {@link ListMetricsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListMetricsCommand extends $Command<ListMetricsCommandInput, ListMetricsCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: ListMetricsCommandInput;
     constructor(input: ListMetricsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListMetricsCommandInput, ListMetricsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceInpu
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceOutput, __MetadataBearer {
 }
-/**
- * <p>Displays the tags associated with a CloudWatch resource. Currently, alarms
- * 			and Contributor Insights rules support tagging.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, ListTagsForResourceCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, ListTagsForResourceCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface PutAnomalyDetectorCommandInput extends PutAnomalyDetectorInput
 }
 export interface PutAnomalyDetectorCommandOutput extends PutAnomalyDetectorOutput, __MetadataBearer {
 }
-/**
- * <p>Creates an anomaly detection model for a CloudWatch metric. You can use the model
- * 			to display a band of expected normal values when the metric is graphed.</p>
- * 		       <p>For more information, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Anomaly_Detection.html">CloudWatch Anomaly Detection</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, PutAnomalyDetectorCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, PutAnomalyDetectorCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new PutAnomalyDetectorCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutAnomalyDetectorCommandInput} for command's `input` shape.
- * @see {@link PutAnomalyDetectorCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutAnomalyDetectorCommand extends $Command<PutAnomalyDetectorCommandInput, PutAnomalyDetectorCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: PutAnomalyDetectorCommandInput;
     constructor(input: PutAnomalyDetectorCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAnomalyDetectorCommandInput, PutAnomalyDetectorCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,64 +6,11 @@ export interface PutCompositeAlarmCommandInput extends PutCompositeAlarmInput {
 }
 export interface PutCompositeAlarmCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Creates or updates a <i>composite alarm</i>. When you create a composite
- * 			alarm, you specify a rule expression for the alarm that takes into account the alarm
- * 			states of other alarms that you have created. The composite alarm goes into ALARM state
- * 			only if all conditions of the rule are met.</p>
- * 		       <p>The alarms specified in a composite alarm's rule expression can include metric alarms
- * 			and other composite alarms.</p>
- * 		       <p>Using composite alarms can reduce
- * 			alarm noise. You can create multiple metric alarms,
- * 			and also create a composite alarm and
- * 			set up alerts only
- * 			for the composite alarm. For example, you could create a composite
- * 			alarm that goes into ALARM state only when more than one of the underlying metric alarms
- * 			are in ALARM state.</p>
- * 		       <p>Currently, the only alarm actions that can be taken by composite alarms are notifying
- * 			SNS topics.</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>
- * 		       <p>When this operation creates an alarm, the alarm state is immediately set to
- * 				<code>INSUFFICIENT_DATA</code>. The alarm is then evaluated and its state is set
- * 			appropriately. Any actions associated with the new state are then executed. For a
- * 			composite alarm, this initial time after creation is the only time that
- * 			the
- * 			alarm can be in <code>INSUFFICIENT_DATA</code> state.</p>
- * 		       <p>When you update an existing alarm, its state is left unchanged, but the update
- * 			completely overwrites the previous configuration of the alarm.</p>
- *
- * 		       <p>If you are an IAM user, you must have <code>iam:CreateServiceLinkedRole</code> to create
- * 			a composite alarm that has Systems Manager OpsItem actions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, PutCompositeAlarmCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, PutCompositeAlarmCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new PutCompositeAlarmCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutCompositeAlarmCommandInput} for command's `input` shape.
- * @see {@link PutCompositeAlarmCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutCompositeAlarmCommand extends $Command<PutCompositeAlarmCommandInput, PutCompositeAlarmCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: PutCompositeAlarmCommandInput;
     constructor(input: PutCompositeAlarmCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutCompositeAlarmCommandInput, PutCompositeAlarmCommandOutput>;
     private serialize;
     private deserialize;