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

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

@@ -6,30 +6,11 @@ export interface DeleteRetentionPolicyCommandInput extends DeleteRetentionPolicy
 }
 export interface DeleteRetentionPolicyCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified retention policy.</p>
- *          <p>Log events do not expire if they belong to log groups without a retention policy.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, DeleteRetentionPolicyCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, DeleteRetentionPolicyCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new DeleteRetentionPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteRetentionPolicyCommandInput} for command's `input` shape.
- * @see {@link DeleteRetentionPolicyCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteRetentionPolicyCommand extends $Command<DeleteRetentionPolicyCommandInput, DeleteRetentionPolicyCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: DeleteRetentionPolicyCommandInput;
     constructor(input: DeleteRetentionPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRetentionPolicyCommandInput, DeleteRetentionPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface DescribeDestinationsCommandInput extends DescribeDestinationsRe
 }
 export interface DescribeDestinationsCommandOutput extends DescribeDestinationsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists all your destinations. The results are ASCII-sorted by destination name.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, DescribeDestinationsCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, DescribeDestinationsCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new DescribeDestinationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDestinationsCommandInput} for command's `input` shape.
- * @see {@link DescribeDestinationsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDestinationsCommand extends $Command<DescribeDestinationsCommandInput, DescribeDestinationsCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: DescribeDestinationsCommandInput;
     constructor(input: DescribeDestinationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDestinationsCommandInput, DescribeDestinationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeExportTasksCommandInput extends DescribeExportTasksRequ
 }
 export interface DescribeExportTasksCommandOutput extends DescribeExportTasksResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the specified export tasks. You can list all your export tasks or filter
- *       the results based on task ID or task status.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, DescribeExportTasksCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, DescribeExportTasksCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new DescribeExportTasksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeExportTasksCommandInput} for command's `input` shape.
- * @see {@link DescribeExportTasksCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeExportTasksCommand extends $Command<DescribeExportTasksCommandInput, DescribeExportTasksCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: DescribeExportTasksCommandInput;
     constructor(input: DescribeExportTasksCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeExportTasksCommandInput, DescribeExportTasksCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface DescribeLogGroupsCommandInput extends DescribeLogGroupsRequest
 }
 export interface DescribeLogGroupsCommandOutput extends DescribeLogGroupsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the specified log groups. You can list all your log groups or filter the results by prefix.
- *       The results are ASCII-sorted by log group name.</p>
- *          <p>CloudWatch Logs doesn’t support IAM policies that control access to the <code>DescribeLogGroups</code> action by using the
- *       <code>aws:ResourceTag/<i>key-name</i>
- *             </code> condition key. Other CloudWatch Logs actions
- *       do support the use of the <code>aws:ResourceTag/<i>key-name</i>
- *             </code> condition key to control access.
- *       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, DescribeLogGroupsCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, DescribeLogGroupsCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new DescribeLogGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLogGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeLogGroupsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLogGroupsCommand extends $Command<DescribeLogGroupsCommandInput, DescribeLogGroupsCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: DescribeLogGroupsCommandInput;
     constructor(input: DescribeLogGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLogGroupsCommandInput, DescribeLogGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribeLogStreamsCommandInput extends DescribeLogStreamsReques
 }
 export interface DescribeLogStreamsCommandOutput extends DescribeLogStreamsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the log streams for the specified log group.
- *       You can list all the log streams or filter the results by prefix.
- *       You can also control how the results are ordered.</p>
- *          <p>This operation has a limit of five transactions per second, after which transactions are throttled.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, DescribeLogStreamsCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, DescribeLogStreamsCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new DescribeLogStreamsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLogStreamsCommandInput} for command's `input` shape.
- * @see {@link DescribeLogStreamsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLogStreamsCommand extends $Command<DescribeLogStreamsCommandInput, DescribeLogStreamsCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: DescribeLogStreamsCommandInput;
     constructor(input: DescribeLogStreamsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLogStreamsCommandInput, DescribeLogStreamsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeMetricFiltersCommandInput extends DescribeMetricFilters
 }
 export interface DescribeMetricFiltersCommandOutput extends DescribeMetricFiltersResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the specified metric filters. You can list all of the metric filters or filter
- *       the results by log name, prefix, metric name, or metric namespace. The results are
- *       ASCII-sorted by filter name.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, DescribeMetricFiltersCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, DescribeMetricFiltersCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new DescribeMetricFiltersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeMetricFiltersCommandInput} for command's `input` shape.
- * @see {@link DescribeMetricFiltersCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeMetricFiltersCommand extends $Command<DescribeMetricFiltersCommandInput, DescribeMetricFiltersCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: DescribeMetricFiltersCommandInput;
     constructor(input: DescribeMetricFiltersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeMetricFiltersCommandInput, DescribeMetricFiltersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeQueriesCommandInput extends DescribeQueriesRequest {
 }
 export interface DescribeQueriesCommandOutput extends DescribeQueriesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of CloudWatch Logs Insights queries that are scheduled, executing, or have
- *       been executed recently in this account. You can request all queries or limit it to queries of
- *       a specific log group or queries with a certain status.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, DescribeQueriesCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, DescribeQueriesCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new DescribeQueriesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeQueriesCommandInput} for command's `input` shape.
- * @see {@link DescribeQueriesCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeQueriesCommand extends $Command<DescribeQueriesCommandInput, DescribeQueriesCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: DescribeQueriesCommandInput;
     constructor(input: DescribeQueriesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeQueriesCommandInput, DescribeQueriesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeQueryDefinitionsCommandInput extends DescribeQueryDefin
 }
 export interface DescribeQueryDefinitionsCommandOutput extends DescribeQueryDefinitionsResponse, __MetadataBearer {
 }
-/**
- * <p>This operation returns a paginated list of your saved CloudWatch Logs Insights query definitions.</p>
- *          <p>You can use the <code>queryDefinitionNamePrefix</code> parameter to limit the results to only the
- *       query definitions that have names that start with a certain string.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, DescribeQueryDefinitionsCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, DescribeQueryDefinitionsCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new DescribeQueryDefinitionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeQueryDefinitionsCommandInput} for command's `input` shape.
- * @see {@link DescribeQueryDefinitionsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeQueryDefinitionsCommand extends $Command<DescribeQueryDefinitionsCommandInput, DescribeQueryDefinitionsCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: DescribeQueryDefinitionsCommandInput;
     constructor(input: DescribeQueryDefinitionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeQueryDefinitionsCommandInput, DescribeQueryDefinitionsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface DescribeSubscriptionFiltersCommandInput extends DescribeSubscri
 }
 export interface DescribeSubscriptionFiltersCommandOutput extends DescribeSubscriptionFiltersResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the subscription filters for the specified log group. You can list all the subscription filters or filter the results by prefix.
- *       The results are ASCII-sorted by filter name.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, DescribeSubscriptionFiltersCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, DescribeSubscriptionFiltersCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new DescribeSubscriptionFiltersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSubscriptionFiltersCommandInput} for command's `input` shape.
- * @see {@link DescribeSubscriptionFiltersCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSubscriptionFiltersCommand extends $Command<DescribeSubscriptionFiltersCommandInput, DescribeSubscriptionFiltersCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: DescribeSubscriptionFiltersCommandInput;
     constructor(input: DescribeSubscriptionFiltersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSubscriptionFiltersCommandInput, DescribeSubscriptionFiltersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DisassociateKmsKeyCommandInput extends DisassociateKmsKeyReques
 }
 export interface DisassociateKmsKeyCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Disassociates the associated Key Management Service customer master key (CMK) from the specified log group.</p>
- *          <p>After the KMS CMK is disassociated from the log group, CloudWatch Logs stops encrypting newly ingested data for the log group.
- *       All previously ingested data remains encrypted, and CloudWatch Logs requires permissions for the CMK whenever the encrypted data is requested.</p>
- *          <p>Note that it can take up to 5 minutes for this operation to take effect.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, DisassociateKmsKeyCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, DisassociateKmsKeyCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new DisassociateKmsKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateKmsKeyCommandInput} for command's `input` shape.
- * @see {@link DisassociateKmsKeyCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateKmsKeyCommand extends $Command<DisassociateKmsKeyCommandInput, DisassociateKmsKeyCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: DisassociateKmsKeyCommandInput;
     constructor(input: DisassociateKmsKeyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateKmsKeyCommandInput, DisassociateKmsKeyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface FilterLogEventsCommandInput extends FilterLogEventsRequest {
 }
 export interface FilterLogEventsCommandOutput extends FilterLogEventsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists log events from the specified log group. You can list all the log events or filter the results
- *       using a filter pattern, a time range, and the name of the log stream.</p>
- *          <p>By default, this operation returns as many log events as can fit in 1 MB (up to 10,000
- *       log events) or all the events found within the time range that you specify. If the results
- *       include a token, then there are more log events available, and you can get additional results
- *       by specifying the token in a subsequent call. This operation can return empty results
- *     while there are more log events available through the token.</p>
- *          <p>The returned log events are sorted by event timestamp, the timestamp when the event was ingested
- *     by CloudWatch Logs, and the ID of the <code>PutLogEvents</code> request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, FilterLogEventsCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, FilterLogEventsCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new FilterLogEventsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link FilterLogEventsCommandInput} for command's `input` shape.
- * @see {@link FilterLogEventsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class FilterLogEventsCommand extends $Command<FilterLogEventsCommandInput, FilterLogEventsCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: FilterLogEventsCommandInput;
     constructor(input: FilterLogEventsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<FilterLogEventsCommandInput, FilterLogEventsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface GetLogEventsCommandInput extends GetLogEventsRequest {
 }
 export interface GetLogEventsCommandOutput extends GetLogEventsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists log events from the specified log stream. You can list all of the log events or
- *       filter using a time range.</p>
- *
- *          <p>By default, this operation returns as many log events as can fit in a response size of 1MB (up to 10,000 log events).
- *       You can get additional log events by specifying one of the tokens in a subsequent call.
- *       This operation can return empty results while there are more log events available through the token.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, GetLogEventsCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, GetLogEventsCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new GetLogEventsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetLogEventsCommandInput} for command's `input` shape.
- * @see {@link GetLogEventsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetLogEventsCommand extends $Command<GetLogEventsCommandInput, GetLogEventsCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: GetLogEventsCommandInput;
     constructor(input: GetLogEventsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLogEventsCommandInput, GetLogEventsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface GetLogGroupFieldsCommandInput extends GetLogGroupFieldsRequest
 }
 export interface GetLogGroupFieldsCommandOutput extends GetLogGroupFieldsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of the fields that are included in log events in the specified log group, along with the percentage of log events
- *     that contain each field. The search is limited to a time period that you specify.</p>
- *          <p>In the results, fields that start with @ are fields generated by CloudWatch Logs. For
- *       example, <code>@timestamp</code> is the timestamp of each log event. For more information about the fields that are
- *       generated by CloudWatch logs, see
- *       <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData-discoverable-fields.html">Supported Logs and Discovered Fields</a>.</p>
- *          <p>The response results are sorted by the frequency percentage, starting
- *     with the highest percentage.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, GetLogGroupFieldsCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, GetLogGroupFieldsCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new GetLogGroupFieldsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetLogGroupFieldsCommandInput} for command's `input` shape.
- * @see {@link GetLogGroupFieldsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetLogGroupFieldsCommand extends $Command<GetLogGroupFieldsCommandInput, GetLogGroupFieldsCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: GetLogGroupFieldsCommandInput;
     constructor(input: GetLogGroupFieldsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLogGroupFieldsCommandInput, GetLogGroupFieldsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetLogRecordCommandInput extends GetLogRecordRequest {
 }
 export interface GetLogRecordCommandOutput extends GetLogRecordResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves all of the fields and values of a single log event. All fields are retrieved,
- *       even if the original query that produced the <code>logRecordPointer</code> retrieved only a
- *       subset of fields. Fields are returned as field name/field value pairs.</p>
- *          <p>The full unparsed log event is returned within <code>@message</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, GetLogRecordCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, GetLogRecordCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new GetLogRecordCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetLogRecordCommandInput} for command's `input` shape.
- * @see {@link GetLogRecordCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetLogRecordCommand extends $Command<GetLogRecordCommandInput, GetLogRecordCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: GetLogRecordCommandInput;
     constructor(input: GetLogRecordCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLogRecordCommandInput, GetLogRecordCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface GetQueryResultsCommandInput extends GetQueryResultsRequest {
 }
 export interface GetQueryResultsCommandOutput extends GetQueryResultsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the results from the specified query.</p>
- *          <p>Only the fields requested in the query are returned, along with a <code>@ptr</code>
- *       field, which is the identifier for the log record. You can use the value of <code>@ptr</code>
- *       in a <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetLogRecord.html">GetLogRecord</a>
- *       operation to get the full log record.</p>
- *          <p>
- *             <code>GetQueryResults</code>
- *       does not start a query execution. To run a query, use <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartQuery.html">StartQuery</a>.</p>
- *          <p>If the value of the <code>Status</code> field in the output is <code>Running</code>, this operation
- *       returns only partial results. If you see a value of <code>Scheduled</code> or <code>Running</code> for the status,
- *       you can retry the operation later to see the final results. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, GetQueryResultsCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, GetQueryResultsCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new GetQueryResultsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetQueryResultsCommandInput} for command's `input` shape.
- * @see {@link GetQueryResultsCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetQueryResultsCommand extends $Command<GetQueryResultsCommandInput, GetQueryResultsCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: GetQueryResultsCommandInput;
     constructor(input: GetQueryResultsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetQueryResultsCommandInput, GetQueryResultsCommandOutput>;
     private serialize;
     private deserialize;