@aws-sdk/client-cloudwatch-logs 3.36.0 → 3.39.0

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

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

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

@@ -6,38 +6,11 @@ export interface PutDestinationCommandInput extends PutDestinationRequest {
 }
 export interface PutDestinationCommandOutput extends PutDestinationResponse, __MetadataBearer {
 }
-/**
- * <p>Creates or updates a destination. This operation is used only to create destinations for cross-account subscriptions.</p>
- *          <p>A destination encapsulates a physical resource (such
- *       as an Amazon Kinesis stream) and enables you to subscribe to a real-time stream of log events
- *       for a different account, ingested using <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html">PutLogEvents</a>.</p>
- *          <p>Through an access policy, a destination controls what is written to it.
- *       By default, <code>PutDestination</code> does not set any access policy with the destination,
- *       which means a cross-account user cannot call <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutSubscriptionFilter.html">PutSubscriptionFilter</a> against
- *       this destination. To enable this, the destination owner must call <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutDestinationPolicy.html">PutDestinationPolicy</a> after <code>PutDestination</code>.</p>
- *          <p>To perform a <code>PutDestination</code> operation, you must also have the
- *     <code>iam:PassRole</code> permission.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, PutDestinationCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, PutDestinationCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new PutDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutDestinationCommandInput} for command's `input` shape.
- * @see {@link PutDestinationCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutDestinationCommand extends $Command<PutDestinationCommandInput, PutDestinationCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: PutDestinationCommandInput;
     constructor(input: PutDestinationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutDestinationCommandInput, PutDestinationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface PutDestinationPolicyCommandInput extends PutDestinationPolicyRe
 }
 export interface PutDestinationPolicyCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Creates or updates an access policy associated with an existing
- *       destination. An access policy is an <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies_overview.html">IAM policy document</a> that is used
- *       to authorize claims to register a subscription filter against a given destination.</p>
- *          <p>If multiple Amazon Web Services accounts are sending logs to this destination, each sender account must be
- *     listed separately in the policy. The policy does not support specifying <code>*</code>
- *     as the Principal or the use of the <code>aws:PrincipalOrgId</code> global key.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, PutDestinationPolicyCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, PutDestinationPolicyCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new PutDestinationPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutDestinationPolicyCommandInput} for command's `input` shape.
- * @see {@link PutDestinationPolicyCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutDestinationPolicyCommand extends $Command<PutDestinationPolicyCommandInput, PutDestinationPolicyCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: PutDestinationPolicyCommandInput;
     constructor(input: PutDestinationPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutDestinationPolicyCommandInput, PutDestinationPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,66 +6,11 @@ export interface PutLogEventsCommandInput extends PutLogEventsRequest {
 }
 export interface PutLogEventsCommandOutput extends PutLogEventsResponse, __MetadataBearer {
 }
-/**
- * <p>Uploads a batch of log events to the specified log stream.</p>
- *          <p>You must include the sequence token obtained from the response of the previous call. An
- *       upload in a newly created log stream does not require a sequence token. You can also get the
- *       sequence token in the <code>expectedSequenceToken</code> field from
- *         <code>InvalidSequenceTokenException</code>. If you call <code>PutLogEvents</code> twice
- *       within a narrow time period using the same value for <code>sequenceToken</code>, both calls
- *       might be successful or one might be rejected.</p>
- *          <p>The batch of events must satisfy the following constraints:</p>
- *          <ul>
- *             <li>
- *                <p>The maximum batch size is 1,048,576 bytes. This size is calculated as the sum of
- *           all event messages in UTF-8, plus 26 bytes for each log event.</p>
- *             </li>
- *             <li>
- *                <p>None of the log events in the batch can be more than 2 hours in the future.</p>
- *             </li>
- *             <li>
- *                <p>None of the log events in the batch can be older than 14 days or older than the retention
- *           period of the log group.</p>
- *             </li>
- *             <li>
- *                <p>The log events in the batch must be in chronological order by their timestamp. The
- *           timestamp is the time the event occurred, expressed as the number of milliseconds after
- *           Jan 1, 1970 00:00:00 UTC. (In Amazon Web Services Tools for PowerShell and the Amazon Web Services SDK for .NET, the
- *           timestamp is specified in .NET format: yyyy-mm-ddThh:mm:ss. For example,
- *           2017-09-15T13:45:30.) </p>
- *             </li>
- *             <li>
- *                <p>A batch of log events in a single request cannot span more than 24 hours. Otherwise, the operation fails.</p>
- *             </li>
- *             <li>
- *                <p>The maximum number of log events in a batch is 10,000.</p>
- *             </li>
- *             <li>
- *                <p>There is a quota of 5 requests per second per log stream. Additional requests are throttled. This quota can't be changed.</p>
- *             </li>
- *          </ul>
- *          <p>If a call to <code>PutLogEvents</code> returns "UnrecognizedClientException" the most likely cause is an invalid Amazon Web Services access key ID or secret key. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, PutLogEventsCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, PutLogEventsCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new PutLogEventsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutLogEventsCommandInput} for command's `input` shape.
- * @see {@link PutLogEventsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutLogEventsCommand extends $Command<PutLogEventsCommandInput, PutLogEventsCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: PutLogEventsCommandInput;
     constructor(input: PutLogEventsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutLogEventsCommandInput, PutLogEventsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,51 +6,11 @@ export interface PutMetricFilterCommandInput extends PutMetricFilterRequest {
 }
 export interface PutMetricFilterCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Creates or updates a metric filter and associates it with the specified log group.
- *       Metric filters allow you to configure rules to extract metric data from log events ingested
- *       through <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html">PutLogEvents</a>.</p>
- *          <p>The maximum number of metric filters that can be associated with a log group is
- *       100.</p>
- *          <p>When you create a metric filter, you can also optionally assign a unit and dimensions
- *     to the metric that is created.</p>
- *          <important>
- *             <p>Metrics extracted from log events are charged as custom metrics.
- *       To prevent unexpected high charges, do not specify high-cardinality fields such as
- *       <code>IPAddress</code> or <code>requestID</code> as dimensions. Each different value
- *       found for
- *       a dimension is treated as a separate metric and accrues charges as a separate custom metric.
- *     </p>
- *             <p>To help prevent accidental high charges, Amazon disables a metric filter
- *         if it generates 1000 different name/value pairs for the dimensions that you
- *         have specified within a certain amount of time.</p>
- *             <p>You can also set up a billing alarm to alert you if your charges are higher than
- *         expected. For more information,
- *         see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/monitor_estimated_charges_with_cloudwatch.html">
- *           Creating a Billing Alarm to Monitor Your Estimated Amazon Web Services Charges</a>.
- *       </p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, PutMetricFilterCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, PutMetricFilterCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new PutMetricFilterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutMetricFilterCommandInput} for command's `input` shape.
- * @see {@link PutMetricFilterCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutMetricFilterCommand extends $Command<PutMetricFilterCommandInput, PutMetricFilterCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: PutMetricFilterCommandInput;
     constructor(input: PutMetricFilterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutMetricFilterCommandInput, PutMetricFilterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,40 +6,11 @@ export interface PutQueryDefinitionCommandInput extends PutQueryDefinitionReques
 }
 export interface PutQueryDefinitionCommandOutput extends PutQueryDefinitionResponse, __MetadataBearer {
 }
-/**
- * <p>Creates or updates a query definition for CloudWatch Logs Insights. For
- *       more information, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html">Analyzing Log Data with CloudWatch Logs Insights</a>.</p>
- *
- *          <p>To update a query definition, specify its
- *         <code>queryDefinitionId</code> in your request. The values of <code>name</code>, <code>queryString</code>,
- *       and <code>logGroupNames</code> are changed to the values that you specify in your update
- *       operation. No current values are retained from the current query definition. For example, if
- *       you update a current query definition that includes log groups, and you don't specify the
- *         <code>logGroupNames</code> parameter in your update operation, the query definition changes
- *       to contain no log groups.</p>
- *          <p>You must have the <code>logs:PutQueryDefinition</code> permission to be able to perform
- *     this operation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, PutQueryDefinitionCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, PutQueryDefinitionCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new PutQueryDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutQueryDefinitionCommandInput} for command's `input` shape.
- * @see {@link PutQueryDefinitionCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutQueryDefinitionCommand extends $Command<PutQueryDefinitionCommandInput, PutQueryDefinitionCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: PutQueryDefinitionCommandInput;
     constructor(input: PutQueryDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutQueryDefinitionCommandInput, PutQueryDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface PutResourcePolicyCommandInput extends PutResourcePolicyRequest
 }
 export interface PutResourcePolicyCommandOutput extends PutResourcePolicyResponse, __MetadataBearer {
 }
-/**
- * <p>Creates or updates a resource policy allowing other Amazon Web Services services to put log events to
- *       this account, such as Amazon Route 53. An account can have up to 10 resource policies per Amazon Web Services
- *       Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, PutResourcePolicyCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, PutResourcePolicyCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new PutResourcePolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutResourcePolicyCommandInput} for command's `input` shape.
- * @see {@link PutResourcePolicyCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutResourcePolicyCommand extends $Command<PutResourcePolicyCommandInput, PutResourcePolicyCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: PutResourcePolicyCommandInput;
     constructor(input: PutResourcePolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutResourcePolicyCommandInput, PutResourcePolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface PutRetentionPolicyCommandInput extends PutRetentionPolicyReques
 }
 export interface PutRetentionPolicyCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Sets the retention of the specified log group. A retention policy allows you to
- *       configure the number of days for which to retain log events in the specified log
- *       group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, PutRetentionPolicyCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, PutRetentionPolicyCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new PutRetentionPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutRetentionPolicyCommandInput} for command's `input` shape.
- * @see {@link PutRetentionPolicyCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutRetentionPolicyCommand extends $Command<PutRetentionPolicyCommandInput, PutRetentionPolicyCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: PutRetentionPolicyCommandInput;
     constructor(input: PutRetentionPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutRetentionPolicyCommandInput, PutRetentionPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,57 +6,11 @@ export interface PutSubscriptionFilterCommandInput extends PutSubscriptionFilter
 }
 export interface PutSubscriptionFilterCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Creates or updates a subscription filter and associates it with the specified log
- *       group. Subscription filters allow you to subscribe to a real-time stream of log events
- *       ingested through <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html">PutLogEvents</a> and have them delivered to a specific
- *       destination. When log events are sent to the
- *       receiving service, they are Base64 encoded
- *       and compressed with the gzip format.</p>
- *          <p>The following destinations are supported for subscription filters:</p>
- *          <ul>
- *             <li>
- *                <p>An Amazon Kinesis stream belonging to the same account as the subscription filter,
- *           for same-account delivery.</p>
- *             </li>
- *             <li>
- *                <p>A logical destination that belongs to a different account, for cross-account delivery.</p>
- *             </li>
- *             <li>
- *                <p>An Amazon Kinesis Firehose delivery stream that belongs to the same account as the
- *           subscription filter, for same-account delivery.</p>
- *             </li>
- *             <li>
- *                <p>An Lambda function that belongs to the same account as the subscription filter,
- *           for same-account delivery.</p>
- *             </li>
- *          </ul>
- *          <p>Each log group can have up to two subscription filters associated with it. If you are
- *       updating an existing filter, you must specify the correct name in <code>filterName</code>.
- *       </p>
- *          <p>To perform a <code>PutSubscriptionFilter</code> operation, you must also have the
- *       <code>iam:PassRole</code> permission.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, PutSubscriptionFilterCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, PutSubscriptionFilterCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new PutSubscriptionFilterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutSubscriptionFilterCommandInput} for command's `input` shape.
- * @see {@link PutSubscriptionFilterCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutSubscriptionFilterCommand extends $Command<PutSubscriptionFilterCommandInput, PutSubscriptionFilterCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: PutSubscriptionFilterCommandInput;
     constructor(input: PutSubscriptionFilterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutSubscriptionFilterCommandInput, PutSubscriptionFilterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface StartQueryCommandInput extends StartQueryRequest {
 }
 export interface StartQueryCommandOutput extends StartQueryResponse, __MetadataBearer {
 }
-/**
- * <p>Schedules a query of a log group using CloudWatch Logs Insights. You specify the log group
- *       and time range to query and the query string to use.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html">CloudWatch Logs Insights Query Syntax</a>.</p>
- *
- *          <p>Queries time out after 15 minutes of execution. If your queries are timing out, reduce the
- *       time range being searched or partition your query into a number of queries.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, StartQueryCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, StartQueryCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new StartQueryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartQueryCommandInput} for command's `input` shape.
- * @see {@link StartQueryCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartQueryCommand extends $Command<StartQueryCommandInput, StartQueryCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: StartQueryCommandInput;
     constructor(input: StartQueryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartQueryCommandInput, StartQueryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface StopQueryCommandInput extends StopQueryRequest {
 }
 export interface StopQueryCommandOutput extends StopQueryResponse, __MetadataBearer {
 }
-/**
- * <p>Stops a CloudWatch Logs Insights query that is in progress. If the query has already ended, the operation
- *     returns an error indicating that the specified query is not running.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, StopQueryCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, StopQueryCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new StopQueryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopQueryCommandInput} for command's `input` shape.
- * @see {@link StopQueryCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopQueryCommand extends $Command<StopQueryCommandInput, StopQueryCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: StopQueryCommandInput;
     constructor(input: StopQueryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopQueryCommandInput, StopQueryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface TagLogGroupCommandInput extends TagLogGroupRequest {
 }
 export interface TagLogGroupCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Adds or updates the specified tags for the specified log group.</p>
- *          <p>To list the tags for a log group, use <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_ListTagsLogGroup.html">ListTagsLogGroup</a>.
- *       To remove tags, use <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_UntagLogGroup.html">UntagLogGroup</a>.</p>
- *          <p>For more information about tags, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#log-group-tagging">Tag Log Groups in Amazon CloudWatch Logs</a>
- *       in the <i>Amazon CloudWatch Logs User Guide</i>.</p>
- *          <p>CloudWatch Logs doesn’t support IAM policies that prevent users from assigning specified tags to
- *       log groups using the <code>aws:Resource/<i>key-name</i>
- *             </code> or <code>aws:TagKeys</code> condition keys.
- *       For more information about using tags to control access, see
- *       <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html">Controlling access to Amazon Web Services resources using tags</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, TagLogGroupCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, TagLogGroupCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new TagLogGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagLogGroupCommandInput} for command's `input` shape.
- * @see {@link TagLogGroupCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagLogGroupCommand extends $Command<TagLogGroupCommandInput, TagLogGroupCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: TagLogGroupCommandInput;
     constructor(input: TagLogGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagLogGroupCommandInput, TagLogGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface TestMetricFilterCommandInput extends TestMetricFilterRequest {
 }
 export interface TestMetricFilterCommandOutput extends TestMetricFilterResponse, __MetadataBearer {
 }
-/**
- * <p>Tests the filter pattern of a metric filter against a sample of log event messages. You
- *       can use this operation to validate the correctness of a metric filter pattern.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, TestMetricFilterCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, TestMetricFilterCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new TestMetricFilterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TestMetricFilterCommandInput} for command's `input` shape.
- * @see {@link TestMetricFilterCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TestMetricFilterCommand extends $Command<TestMetricFilterCommandInput, TestMetricFilterCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: TestMetricFilterCommandInput;
     constructor(input: TestMetricFilterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestMetricFilterCommandInput, TestMetricFilterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface UntagLogGroupCommandInput extends UntagLogGroupRequest {
 }
 export interface UntagLogGroupCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Removes the specified tags from the specified log group.</p>
- *          <p>To list the tags for a log group, use <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_ListTagsLogGroup.html">ListTagsLogGroup</a>.
- *       To add tags, use <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_TagLogGroup.html">TagLogGroup</a>.</p>
- *          <p>CloudWatch Logs doesn’t support IAM policies that prevent users from assigning specified tags to
- *       log groups using the <code>aws:Resource/<i>key-name</i>
- *             </code> or <code>aws:TagKeys</code> condition keys.
- *      </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, UntagLogGroupCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, UntagLogGroupCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new UntagLogGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagLogGroupCommandInput} for command's `input` shape.
- * @see {@link UntagLogGroupCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagLogGroupCommand extends $Command<UntagLogGroupCommandInput, UntagLogGroupCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: UntagLogGroupCommandInput;
     constructor(input: UntagLogGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagLogGroupCommandInput, UntagLogGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,42 @@
+export * from "./AssociateKmsKeyCommand";
+export * from "./CancelExportTaskCommand";
+export * from "./CreateExportTaskCommand";
+export * from "./CreateLogGroupCommand";
+export * from "./CreateLogStreamCommand";
+export * from "./DeleteDestinationCommand";
+export * from "./DeleteLogGroupCommand";
+export * from "./DeleteLogStreamCommand";
+export * from "./DeleteMetricFilterCommand";
+export * from "./DeleteQueryDefinitionCommand";
+export * from "./DeleteResourcePolicyCommand";
+export * from "./DeleteRetentionPolicyCommand";
+export * from "./DeleteSubscriptionFilterCommand";
+export * from "./DescribeDestinationsCommand";
+export * from "./DescribeExportTasksCommand";
+export * from "./DescribeLogGroupsCommand";
+export * from "./DescribeLogStreamsCommand";
+export * from "./DescribeMetricFiltersCommand";
+export * from "./DescribeQueriesCommand";
+export * from "./DescribeQueryDefinitionsCommand";
+export * from "./DescribeResourcePoliciesCommand";
+export * from "./DescribeSubscriptionFiltersCommand";
+export * from "./DisassociateKmsKeyCommand";
+export * from "./FilterLogEventsCommand";
+export * from "./GetLogEventsCommand";
+export * from "./GetLogGroupFieldsCommand";
+export * from "./GetLogRecordCommand";
+export * from "./GetQueryResultsCommand";
+export * from "./ListTagsLogGroupCommand";
+export * from "./PutDestinationCommand";
+export * from "./PutDestinationPolicyCommand";
+export * from "./PutLogEventsCommand";
+export * from "./PutMetricFilterCommand";
+export * from "./PutQueryDefinitionCommand";
+export * from "./PutResourcePolicyCommand";
+export * from "./PutRetentionPolicyCommand";
+export * from "./PutSubscriptionFilterCommand";
+export * from "./StartQueryCommand";
+export * from "./StopQueryCommand";
+export * from "./TagLogGroupCommand";
+export * from "./TestMetricFilterCommand";
+export * from "./UntagLogGroupCommand";