@aws-sdk/client-cloudwatch 3.36.0 → 3.39.0

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

@@ -6,42 +6,11 @@ export interface PutDashboardCommandInput extends PutDashboardInput {
 }
 export interface PutDashboardCommandOutput extends PutDashboardOutput, __MetadataBearer {
 }
-/**
- * <p>Creates a dashboard if it does not already exist, or updates an existing dashboard. If you update a dashboard,
- * 		the entire contents are replaced with what you specify here.</p>
- * 		       <p>All dashboards in your account are global, not region-specific.</p>
- * 		       <p>A simple way to create a dashboard using <code>PutDashboard</code> is to copy an
- * 			existing dashboard. To copy an existing dashboard using the console, you can load the dashboard
- * 			and then use the View/edit source command in the Actions menu to display the JSON  block
- * 			for that dashboard. Another way to copy a dashboard is to
- * 			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>.</p>
- * 		       <p>When you create a dashboard with <code>PutDashboard</code>, a good practice is to
- * 			add a text widget at the top of the dashboard with a message that the dashboard was created by script and should
- * 		not be changed in the console. This message could also point console users to the location
- * 		of the <code>DashboardBody</code> script or the CloudFormation template used to create the
- * 		dashboard.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, PutDashboardCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, PutDashboardCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new PutDashboardCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutDashboardCommandInput} for command's `input` shape.
- * @see {@link PutDashboardCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutDashboardCommand extends $Command<PutDashboardCommandInput, PutDashboardCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: PutDashboardCommandInput;
     constructor(input: PutDashboardCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutDashboardCommandInput, PutDashboardCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface PutInsightRuleCommandInput extends PutInsightRuleInput {
 }
 export interface PutInsightRuleCommandOutput extends PutInsightRuleOutput, __MetadataBearer {
 }
-/**
- * <p>Creates a Contributor Insights rule. Rules evaluate log events in a
- * 		CloudWatch Logs log group, enabling you to find contributor data for the log events in that log group. For more information,
- * 		see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContributorInsights.html">Using Contributor Insights to Analyze High-Cardinality Data</a>.</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, PutInsightRuleCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, PutInsightRuleCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new PutInsightRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutInsightRuleCommandInput} for command's `input` shape.
- * @see {@link PutInsightRuleCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutInsightRuleCommand extends $Command<PutInsightRuleCommandInput, PutInsightRuleCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: PutInsightRuleCommandInput;
     constructor(input: PutInsightRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutInsightRuleCommandInput, PutInsightRuleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,92 +6,11 @@ export interface PutMetricAlarmCommandInput extends PutMetricAlarmInput {
 }
 export interface PutMetricAlarmCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Creates or updates an alarm and associates it with the specified metric, metric math expression,
- * 			or anomaly detection model.</p>
- *
- *
- * 		       <p>Alarms based on anomaly detection models cannot have Auto Scaling actions.</p>
- * 		       <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.</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
- * 			Amazon EC2 permissions for some alarm operations:</p>
- * 		       <ul>
- *             <li>
- * 				           <p>The <code>iam:CreateServiceLinkedRole</code> for all alarms with EC2 actions</p>
- *
- * 			         </li>
- *             <li>
- *
- * 				           <p>The <code>iam:CreateServiceLinkedRole</code> to create an alarm
- * 					with Systems Manager OpsItem actions.</p>
- * 			         </li>
- *          </ul>
- *
- *
- *
- *
- *
- *
- * 		       <p>The first time you create an alarm in the
- * 			Management Console, the CLI, or by using the PutMetricAlarm API, CloudWatch
- * 			creates the necessary service-linked role for you. The service-linked roles
- * 			are called <code>AWSServiceRoleForCloudWatchEvents</code> and
- * 			<code>AWSServiceRoleForCloudWatchAlarms_ActionSSM</code>.
- * 			For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role">Amazon Web Services service-linked role</a>.</p>
- *
- * 		       <p>
- *             <b>Cross-account alarms</b>
- *          </p>
- *
- * 		       <p>You can set an alarm on metrics in the current account, or in another
- * 			account. To create a cross-account alarm that watches a metric in a different account, you must have completed the following
- * 			pre-requisites:</p>
- * 		       <ul>
- *             <li>
- *                <p>The account where the metrics are located (the <i>sharing account</i>) must
- * 				already have a sharing role named <b>CloudWatch-CrossAccountSharingRole</b>. If it does not already
- * 				have this role, you must create it using the instructions in <b>Set up a
- * 					sharing account</b> in <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html#enable-cross-account-cross-Region">
- * 					Cross-account cross-Region CloudWatch console</a>. The policy for that
- * 				role must grant access
- * 				to the ID of the account where you are creating the alarm.
- * 			</p>
- *             </li>
- *             <li>
- *                <p>The account where you are creating the alarm (the <i>monitoring account</i>) must
- * 				already have a service-linked role named
- * 				<b>AWSServiceRoleForCloudWatchCrossAccount</b> to allow
- * 				CloudWatch to assume the sharing role in the sharing account. If it does not, you must create it following the directions in <b>Set up a
- * 					monitoring account</b> in <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Cross-Account-Cross-Region.html#enable-cross-account-cross-Region">
- * 						Cross-account cross-Region CloudWatch console</a>.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, PutMetricAlarmCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, PutMetricAlarmCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new PutMetricAlarmCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutMetricAlarmCommandInput} for command's `input` shape.
- * @see {@link PutMetricAlarmCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutMetricAlarmCommand extends $Command<PutMetricAlarmCommandInput, PutMetricAlarmCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: PutMetricAlarmCommandInput;
     constructor(input: PutMetricAlarmCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutMetricAlarmCommandInput, PutMetricAlarmCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,73 +6,11 @@ export interface PutMetricDataCommandInput extends PutMetricDataInput {
 }
 export interface PutMetricDataCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Publishes metric data points to Amazon CloudWatch. CloudWatch associates
- * 			the data points with the specified metric. If the specified metric does not exist,
- * 			CloudWatch creates the metric. When CloudWatch creates a metric, it can
- * 			take up to fifteen minutes for the metric to appear in calls to <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_ListMetrics.html">ListMetrics</a>.</p>
- *
- * 		       <p>You can publish either individual data points in the <code>Value</code> field, or
- * 		arrays of values and the number of times each value occurred during the period by using the
- * 		<code>Values</code> and <code>Counts</code> fields in the <code>MetricDatum</code> structure. Using
- * 		the <code>Values</code> and <code>Counts</code> method enables you to publish up to 150 values per metric
- * 			with one <code>PutMetricData</code> request, and
- * 		supports retrieving percentile statistics on this data.</p>
- * 		       <p>Each <code>PutMetricData</code> request is limited to 40 KB in size for HTTP POST requests. You can
- * 			send a payload compressed by gzip. Each request
- * 		is also limited to no more than 20 different metrics.</p>
- * 		       <p>Although the <code>Value</code> parameter accepts numbers of type
- * 			<code>Double</code>, CloudWatch rejects values that are either too small
- * 			or too large. Values must be in the range of -2^360 to 2^360. In addition, special values (for example, NaN, +Infinity,
- * 			-Infinity) are not supported.</p>
- * 		       <p>You can use up to 10 dimensions per metric to further clarify what data the metric collects. Each dimension
- * 			consists of a Name and Value pair. For more information about specifying dimensions, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/publishingMetrics.html">Publishing Metrics</a> in the
- * 			<i>Amazon CloudWatch User Guide</i>.</p>
- *
- * 		       <p>You specify the time stamp to be associated with each data point. You can specify
- * 		time stamps that are as much as two weeks before the current date, and as much as 2 hours after
- * 		the current day and time.</p>
- * 		       <p>Data points with time stamps from 24 hours ago or longer can take at least 48
- * 			hours to become available for <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> from the time they
- * 			are submitted. Data points with time stamps between 3 and 24 hours ago can take as much as 2 hours to become available
- * 			for for <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>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 <code>SampleCount</code> value of the statistic set is 1 and <code>Min</code>,
- * 					<code>Max</code>, and <code>Sum</code> are all equal.</p>
- *             </li>
- *             <li>
- *                <p>The <code>Min</code> and
- * 					<code>Max</code> are equal, and <code>Sum</code> is equal to <code>Min</code>
- * 					multiplied by <code>SampleCount</code>.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, PutMetricDataCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, PutMetricDataCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new PutMetricDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutMetricDataCommandInput} for command's `input` shape.
- * @see {@link PutMetricDataCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutMetricDataCommand extends $Command<PutMetricDataCommandInput, PutMetricDataCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: PutMetricDataCommandInput;
     constructor(input: PutMetricDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutMetricDataCommandInput, PutMetricDataCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,56 +6,11 @@ export interface PutMetricStreamCommandInput extends PutMetricStreamInput {
 }
 export interface PutMetricStreamCommandOutput extends PutMetricStreamOutput, __MetadataBearer {
 }
-/**
- * <p>Creates or updates a metric stream. Metric streams can automatically stream CloudWatch metrics
- * 			to Amazon Web Services destinations including
- * 			Amazon S3 and to many third-party solutions.</p>
- * 		       <p>For more information, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Metric-Streams.html">
- * 		Using Metric Streams</a>.</p>
- * 		       <p>To create a metric stream,
- * 			you must be logged on to an account that has the <code>iam:PassRole</code> permission
- * 			and either the <code>CloudWatchFullAccess</code>
- * 		policy or the <code>cloudwatch:PutMetricStream</code>
- * 		permission.</p>
- * 		       <p>When you create or update a metric stream, you choose one of the following:</p>
- * 		       <ul>
- *             <li>
- *                <p>Stream metrics from all metric namespaces in the account.</p>
- *             </li>
- *             <li>
- *                <p>Stream metrics from all metric namespaces in the account, except
- * 				for the namespaces that you list in <code>ExcludeFilters</code>.</p>
- *             </li>
- *             <li>
- *                <p>Stream metrics from only the metric namespaces that you list in
- * 				<code>IncludeFilters</code>.</p>
- *             </li>
- *          </ul>
- *
- * 		       <p>When you use <code>PutMetricStream</code> to create a new metric stream, the stream
- * 		is created in the <code>running</code> state. If you use it to update an existing stream,
- * 		the state of the stream is not changed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, PutMetricStreamCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, PutMetricStreamCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new PutMetricStreamCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutMetricStreamCommandInput} for command's `input` shape.
- * @see {@link PutMetricStreamCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutMetricStreamCommand extends $Command<PutMetricStreamCommandInput, PutMetricStreamCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: PutMetricStreamCommandInput;
     constructor(input: PutMetricStreamCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutMetricStreamCommandInput, PutMetricStreamCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,44 +6,11 @@ export interface SetAlarmStateCommandInput extends SetAlarmStateInput {
 }
 export interface SetAlarmStateCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Temporarily sets the state of an alarm for testing purposes. When the updated
- * 			state differs from the previous value, the action configured for
- * 			the appropriate state is invoked. For example, if your alarm is configured to send an
- * 			Amazon SNS message when an alarm is triggered, temporarily changing the alarm state to
- * 			<code>ALARM</code> sends an SNS message.</p>
- * 		       <p>Metric alarms
- * 			returns to their actual state quickly, often within seconds. Because the metric alarm state change
- * 			happens quickly, it is typically only visible in the alarm's <b>History</b> tab in the Amazon CloudWatch console or through
- * 			<a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_DescribeAlarmHistory.html">DescribeAlarmHistory</a>.</p>
- * 		       <p>If you use <code>SetAlarmState</code> on a composite alarm, the composite alarm is not guaranteed to return
- * 			to its actual state. It
- * 			returns to its actual state only once any of its children alarms change state. It is also
- * 			reevaluated if you update its
- * 			configuration.</p>
- * 		       <p>If an alarm triggers EC2 Auto Scaling policies or application Auto Scaling policies, you must include
- * 		information in the <code>StateReasonData</code> parameter to enable the policy to take the correct action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, SetAlarmStateCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, SetAlarmStateCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new SetAlarmStateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetAlarmStateCommandInput} for command's `input` shape.
- * @see {@link SetAlarmStateCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SetAlarmStateCommand extends $Command<SetAlarmStateCommandInput, SetAlarmStateCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: SetAlarmStateCommandInput;
     constructor(input: SetAlarmStateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetAlarmStateCommandInput, SetAlarmStateCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,39 +6,11 @@ export interface TagResourceCommandInput extends TagResourceInput {
 }
 export interface TagResourceCommandOutput extends TagResourceOutput, __MetadataBearer {
 }
-/**
- * <p>Assigns one or more tags (key-value pairs) to the specified CloudWatch resource. Currently, the only CloudWatch resources that
- * 			can be tagged are alarms and Contributor Insights rules.</p>
- * 		       <p>Tags can help you organize and categorize your resources. You can also use them to scope user
- * 			permissions by granting a user
- * 			permission to access or change only resources with certain tag values.</p>
- * 		       <p>Tags don't have any semantic meaning to Amazon Web Services and are interpreted strictly as strings of characters.</p>
- * 		       <p>You can use the <code>TagResource</code> action with an alarm that already has tags. If you specify a new tag key for the alarm,
- * 			this tag is appended to the list of tags associated
- * 			with the alarm. If you specify a tag key that is already associated with the alarm, the new tag value that you specify replaces
- * 			the previous value for that tag.</p>
- * 		       <p>You can associate as many as 50 tags with a CloudWatch resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchClient, TagResourceCommand } from "@aws-sdk/client-cloudwatch"; // ES Modules import
- * // const { CloudWatchClient, TagResourceCommand } = require("@aws-sdk/client-cloudwatch"); // CommonJS import
- * const client = new CloudWatchClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, CloudWatchClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -0,0 +1,36 @@
+export * from "./DeleteAlarmsCommand";
+export * from "./DeleteAnomalyDetectorCommand";
+export * from "./DeleteDashboardsCommand";
+export * from "./DeleteInsightRulesCommand";
+export * from "./DeleteMetricStreamCommand";
+export * from "./DescribeAlarmHistoryCommand";
+export * from "./DescribeAlarmsCommand";
+export * from "./DescribeAlarmsForMetricCommand";
+export * from "./DescribeAnomalyDetectorsCommand";
+export * from "./DescribeInsightRulesCommand";
+export * from "./DisableAlarmActionsCommand";
+export * from "./DisableInsightRulesCommand";
+export * from "./EnableAlarmActionsCommand";
+export * from "./EnableInsightRulesCommand";
+export * from "./GetDashboardCommand";
+export * from "./GetInsightRuleReportCommand";
+export * from "./GetMetricDataCommand";
+export * from "./GetMetricStatisticsCommand";
+export * from "./GetMetricStreamCommand";
+export * from "./GetMetricWidgetImageCommand";
+export * from "./ListDashboardsCommand";
+export * from "./ListMetricStreamsCommand";
+export * from "./ListMetricsCommand";
+export * from "./ListTagsForResourceCommand";
+export * from "./PutAnomalyDetectorCommand";
+export * from "./PutCompositeAlarmCommand";
+export * from "./PutDashboardCommand";
+export * from "./PutInsightRuleCommand";
+export * from "./PutMetricAlarmCommand";
+export * from "./PutMetricDataCommand";
+export * from "./PutMetricStreamCommand";
+export * from "./SetAlarmStateCommand";
+export * from "./StartMetricStreamsCommand";
+export * from "./StopMetricStreamsCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";

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

@@ -1,49 +1,6 @@
-export * from "./CloudWatchClient";
 export * from "./CloudWatch";
-export * from "./commands/DeleteAlarmsCommand";
-export * from "./commands/DeleteAnomalyDetectorCommand";
-export * from "./commands/DeleteDashboardsCommand";
-export * from "./commands/DeleteInsightRulesCommand";
-export * from "./commands/DeleteMetricStreamCommand";
-export * from "./commands/DescribeAlarmHistoryCommand";
-export * from "./pagination/DescribeAlarmHistoryPaginator";
-export * from "./commands/DescribeAlarmsCommand";
-export * from "./pagination/DescribeAlarmsPaginator";
-export * from "./waiters/waitForAlarmExists";
-export * from "./waiters/waitForCompositeAlarmExists";
-export * from "./commands/DescribeAlarmsForMetricCommand";
-export * from "./commands/DescribeAnomalyDetectorsCommand";
-export * from "./commands/DescribeInsightRulesCommand";
-export * from "./pagination/DescribeInsightRulesPaginator";
-export * from "./commands/DisableAlarmActionsCommand";
-export * from "./commands/DisableInsightRulesCommand";
-export * from "./commands/EnableAlarmActionsCommand";
-export * from "./commands/EnableInsightRulesCommand";
-export * from "./commands/GetDashboardCommand";
-export * from "./commands/GetInsightRuleReportCommand";
-export * from "./commands/GetMetricDataCommand";
-export * from "./pagination/GetMetricDataPaginator";
-export * from "./commands/GetMetricStatisticsCommand";
-export * from "./commands/GetMetricStreamCommand";
-export * from "./commands/GetMetricWidgetImageCommand";
-export * from "./commands/ListDashboardsCommand";
-export * from "./pagination/ListDashboardsPaginator";
-export * from "./commands/ListMetricsCommand";
-export * from "./pagination/ListMetricsPaginator";
-export * from "./commands/ListMetricStreamsCommand";
-export * from "./pagination/ListMetricStreamsPaginator";
-export * from "./commands/ListTagsForResourceCommand";
-export * from "./commands/PutAnomalyDetectorCommand";
-export * from "./commands/PutCompositeAlarmCommand";
-export * from "./commands/PutDashboardCommand";
-export * from "./commands/PutInsightRuleCommand";
-export * from "./commands/PutMetricAlarmCommand";
-export * from "./commands/PutMetricDataCommand";
-export * from "./commands/PutMetricStreamCommand";
-export * from "./commands/SetAlarmStateCommand";
-export * from "./commands/StartMetricStreamsCommand";
-export * from "./commands/StopMetricStreamsCommand";
-export * from "./commands/TagResourceCommand";
-export * from "./commands/UntagResourceCommand";
-export * from "./pagination/Interfaces";
-export * from "./models/index";
+export * from "./CloudWatchClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export * from "./waiters";