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

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

@@ -51,157 +51,59 @@ import { UntagLogGroupCommandInput, UntagLogGroupCommandOutput } from "./command
 export declare type ServiceInputTypes = AssociateKmsKeyCommandInput | CancelExportTaskCommandInput | CreateExportTaskCommandInput | CreateLogGroupCommandInput | CreateLogStreamCommandInput | DeleteDestinationCommandInput | DeleteLogGroupCommandInput | DeleteLogStreamCommandInput | DeleteMetricFilterCommandInput | DeleteQueryDefinitionCommandInput | DeleteResourcePolicyCommandInput | DeleteRetentionPolicyCommandInput | DeleteSubscriptionFilterCommandInput | DescribeDestinationsCommandInput | DescribeExportTasksCommandInput | DescribeLogGroupsCommandInput | DescribeLogStreamsCommandInput | DescribeMetricFiltersCommandInput | DescribeQueriesCommandInput | DescribeQueryDefinitionsCommandInput | DescribeResourcePoliciesCommandInput | DescribeSubscriptionFiltersCommandInput | DisassociateKmsKeyCommandInput | FilterLogEventsCommandInput | GetLogEventsCommandInput | GetLogGroupFieldsCommandInput | GetLogRecordCommandInput | GetQueryResultsCommandInput | ListTagsLogGroupCommandInput | PutDestinationCommandInput | PutDestinationPolicyCommandInput | PutLogEventsCommandInput | PutMetricFilterCommandInput | PutQueryDefinitionCommandInput | PutResourcePolicyCommandInput | PutRetentionPolicyCommandInput | PutSubscriptionFilterCommandInput | StartQueryCommandInput | StopQueryCommandInput | TagLogGroupCommandInput | TestMetricFilterCommandInput | UntagLogGroupCommandInput;
 export declare type ServiceOutputTypes = AssociateKmsKeyCommandOutput | CancelExportTaskCommandOutput | CreateExportTaskCommandOutput | CreateLogGroupCommandOutput | CreateLogStreamCommandOutput | DeleteDestinationCommandOutput | DeleteLogGroupCommandOutput | DeleteLogStreamCommandOutput | DeleteMetricFilterCommandOutput | DeleteQueryDefinitionCommandOutput | DeleteResourcePolicyCommandOutput | DeleteRetentionPolicyCommandOutput | DeleteSubscriptionFilterCommandOutput | DescribeDestinationsCommandOutput | DescribeExportTasksCommandOutput | DescribeLogGroupsCommandOutput | DescribeLogStreamsCommandOutput | DescribeMetricFiltersCommandOutput | DescribeQueriesCommandOutput | DescribeQueryDefinitionsCommandOutput | DescribeResourcePoliciesCommandOutput | DescribeSubscriptionFiltersCommandOutput | DisassociateKmsKeyCommandOutput | FilterLogEventsCommandOutput | GetLogEventsCommandOutput | GetLogGroupFieldsCommandOutput | GetLogRecordCommandOutput | GetQueryResultsCommandOutput | ListTagsLogGroupCommandOutput | PutDestinationCommandOutput | PutDestinationPolicyCommandOutput | PutLogEventsCommandOutput | PutMetricFilterCommandOutput | PutQueryDefinitionCommandOutput | PutResourcePolicyCommandOutput | PutRetentionPolicyCommandOutput | PutSubscriptionFilterCommandOutput | StartQueryCommandOutput | StopQueryCommandOutput | TagLogGroupCommandOutput | TestMetricFilterCommandOutput | UntagLogGroupCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type CloudWatchLogsClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of CloudWatchLogsClient class constructor that set the region, credentials and other options.
- */
+
 export interface CloudWatchLogsClientConfig extends CloudWatchLogsClientConfigType {
 }
 declare type CloudWatchLogsClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of CloudWatchLogsClient class. This is resolved and normalized from the {@link CloudWatchLogsClientConfig | constructor configuration interface}.
- */
+
 export interface CloudWatchLogsClientResolvedConfig extends CloudWatchLogsClientResolvedConfigType {
 }
-/**
- * <p>You can use Amazon CloudWatch Logs to monitor, store, and access your log files from
- *       EC2 instances, CloudTrail, and other sources. You can then retrieve the associated
- *       log data from CloudWatch Logs using the CloudWatch console, CloudWatch Logs commands in the
- *       Amazon Web Services CLI, CloudWatch Logs API, or CloudWatch Logs SDK.</p>
- *          <p>You can use CloudWatch Logs to:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <b>Monitor logs from EC2 instances in real-time</b>: You
- *           can use CloudWatch Logs to monitor applications and systems using log data. For example,
- *           CloudWatch Logs can track the number of errors that occur in your application logs and
- *           send you a notification whenever the rate of errors exceeds a threshold that you specify.
- *           CloudWatch Logs uses your log data for monitoring so no code changes are required. For
- *           example, you can monitor application logs for specific literal terms (such as
- *           "NullReferenceException") or count the number of occurrences of a literal term at a
- *           particular position in log data (such as "404" status codes in an Apache access log). When
- *           the term you are searching for is found, CloudWatch Logs reports the data to a CloudWatch
- *           metric that you specify.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <b>Monitor CloudTrail logged events</b>: You can
- *           create alarms in CloudWatch and receive notifications of particular API activity as
- *           captured by CloudTrail. You can use the notification to perform troubleshooting.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <b>Archive log data</b>: You can use CloudWatch Logs to
- *           store your log data in highly durable storage. You can change the log retention setting so
- *           that any log events older than this setting are automatically deleted. The CloudWatch Logs
- *           agent makes it easy to quickly send both rotated and non-rotated log data off of a host
- *           and into the log service. You can then access the raw log data when you need it.</p>
- *             </li>
- *          </ul>
- */
+
 export declare class CloudWatchLogsClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, CloudWatchLogsClientResolvedConfig> {
-    /**
-     * The resolved configuration of CloudWatchLogsClient class. This is resolved and normalized from the {@link CloudWatchLogsClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: CloudWatchLogsClientResolvedConfig;
     constructor(configuration: CloudWatchLogsClientConfig);
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
+    
     destroy(): void;
 }
 export {};

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

@@ -6,41 +6,11 @@ export interface AssociateKmsKeyCommandInput extends AssociateKmsKeyRequest {
 }
 export interface AssociateKmsKeyCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Associates the specified Key Management Service customer master key (CMK) with the specified log group.</p>
- *          <p>Associating an KMS CMK with a log group overrides any existing associations between the log group and a CMK.
- *       After a CMK is associated with a log group, all newly ingested data for the log group is encrypted using the CMK.
- *       This association is stored as long as the data encrypted with the CMK is still within CloudWatch Logs.
- *       This enables CloudWatch Logs to decrypt this data whenever it is requested.</p>
- *          <important>
- *             <p>CloudWatch Logs supports only symmetric CMKs. Do not use an associate an asymmetric CMK
- *         with your log group. For more information, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html">Using Symmetric and Asymmetric
- *           Keys</a>.</p>
- *          </important>
- *          <p>It can take up to 5 minutes for this operation to take effect.</p>
- *          <p>If you attempt to associate a CMK with a log group but the CMK does not exist or the
- *       CMK is disabled, you receive an <code>InvalidParameterException</code> error. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, AssociateKmsKeyCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, AssociateKmsKeyCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new AssociateKmsKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateKmsKeyCommandInput} for command's `input` shape.
- * @see {@link AssociateKmsKeyCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociateKmsKeyCommand extends $Command<AssociateKmsKeyCommandInput, AssociateKmsKeyCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: AssociateKmsKeyCommandInput;
     constructor(input: AssociateKmsKeyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateKmsKeyCommandInput, AssociateKmsKeyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CancelExportTaskCommandInput extends CancelExportTaskRequest {
 }
 export interface CancelExportTaskCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Cancels the specified export task.</p>
- *          <p>The task must be in the <code>PENDING</code> or <code>RUNNING</code> state.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, CancelExportTaskCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, CancelExportTaskCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new CancelExportTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CancelExportTaskCommandInput} for command's `input` shape.
- * @see {@link CancelExportTaskCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CancelExportTaskCommand extends $Command<CancelExportTaskCommandInput, CancelExportTaskCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: CancelExportTaskCommandInput;
     constructor(input: CancelExportTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelExportTaskCommandInput, CancelExportTaskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,42 +6,11 @@ export interface CreateExportTaskCommandInput extends CreateExportTaskRequest {
 }
 export interface CreateExportTaskCommandOutput extends CreateExportTaskResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an export task, which allows you to efficiently export data from a
- *       log group to an Amazon S3 bucket. When you perform a <code>CreateExportTask</code>
- *       operation, you must use credentials that have permission to write to the S3 bucket
- *       that you specify as the destination.</p>
- *          <p>This is an asynchronous call. If all the required information is provided, this
- *       operation initiates an export task and responds with the ID of the task. After the task has started,
- *       you can use <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeExportTasks.html">DescribeExportTasks</a> to get the status of the export task. Each account can
- *       only have one active (<code>RUNNING</code> or <code>PENDING</code>) export task at a time.
- *       To cancel an export task, use <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CancelExportTask.html">CancelExportTask</a>.</p>
- *          <p>You can export logs from multiple log groups or multiple time ranges to the same S3
- *       bucket. To separate out log data for each export task, you can specify a prefix to be used as
- *       the Amazon S3 key prefix for all exported objects.</p>
- *          <p>Exporting to S3 buckets that are encrypted with AES-256 is supported. Exporting to S3 buckets
- *       encrypted with SSE-KMS is not supported. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, CreateExportTaskCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, CreateExportTaskCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new CreateExportTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateExportTaskCommandInput} for command's `input` shape.
- * @see {@link CreateExportTaskCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateExportTaskCommand extends $Command<CreateExportTaskCommandInput, CreateExportTaskCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: CreateExportTaskCommandInput;
     constructor(input: CreateExportTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateExportTaskCommandInput, CreateExportTaskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,55 +6,11 @@ export interface CreateLogGroupCommandInput extends CreateLogGroupRequest {
 }
 export interface CreateLogGroupCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Creates a log group with the specified name. You can create up to 20,000 log groups per account.</p>
- *          <p>You must use the following guidelines when naming a log group:</p>
- *          <ul>
- *             <li>
- *                <p>Log group names must be unique within a region for an Amazon Web Services account.</p>
- *             </li>
- *             <li>
- *                <p>Log group names can be between 1 and 512 characters long.</p>
- *             </li>
- *             <li>
- *                <p>Log group names consist of the following characters: a-z, A-Z, 0-9, '_' (underscore), '-' (hyphen),
- *           '/' (forward slash), '.' (period), and '#' (number sign)</p>
- *             </li>
- *          </ul>
- *          <p>When you create a log group, by default the log events in the log group never expire. To set
- *     a retention policy so that events expire and are deleted after a specified time, use
- *       <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutRetentionPolicy.html">PutRetentionPolicy</a>.</p>
- *          <p>If you associate a Key Management Service customer master key (CMK) with the log group, ingested data is encrypted using the CMK.
- *       This association is stored as long as the data encrypted with the CMK is still within CloudWatch Logs.
- *       This enables CloudWatch Logs to decrypt this data whenever it is requested.</p>
- *          <p>If you attempt to associate a CMK with the log group but the CMK does not exist or the
- *       CMK is disabled, you receive an <code>InvalidParameterException</code> error. </p>
- *          <important>
- *             <p>CloudWatch Logs supports only symmetric CMKs. Do not associate an asymmetric CMK with
- *         your log group. For more information, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html">Using Symmetric and Asymmetric
- *           Keys</a>.</p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, CreateLogGroupCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, CreateLogGroupCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new CreateLogGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLogGroupCommandInput} for command's `input` shape.
- * @see {@link CreateLogGroupCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateLogGroupCommand extends $Command<CreateLogGroupCommandInput, CreateLogGroupCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: CreateLogGroupCommandInput;
     constructor(input: CreateLogGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLogGroupCommandInput, CreateLogGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,45 +6,11 @@ export interface CreateLogStreamCommandInput extends CreateLogStreamRequest {
 }
 export interface CreateLogStreamCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Creates a log stream for the specified log group. A log stream is a sequence of log events
- *       that originate from a single source, such as an application instance or a resource that is
- *       being monitored.</p>
- *          <p>There is no limit on the number of log streams that you can create for a log group. There is a limit
- *     of 50 TPS on <code>CreateLogStream</code> operations, after which transactions are throttled.</p>
- *          <p>You must use the following guidelines when naming a log stream:</p>
- *          <ul>
- *             <li>
- *                <p>Log stream names must be unique within the log group.</p>
- *             </li>
- *             <li>
- *                <p>Log stream names can be between 1 and 512 characters long.</p>
- *             </li>
- *             <li>
- *                <p>The ':' (colon) and '*' (asterisk) characters are not allowed.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, CreateLogStreamCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, CreateLogStreamCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new CreateLogStreamCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLogStreamCommandInput} for command's `input` shape.
- * @see {@link CreateLogStreamCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateLogStreamCommand extends $Command<CreateLogStreamCommandInput, CreateLogStreamCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: CreateLogStreamCommandInput;
     constructor(input: CreateLogStreamCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLogStreamCommandInput, CreateLogStreamCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeleteDestinationCommandInput extends DeleteDestinationRequest
 }
 export interface DeleteDestinationCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified destination, and eventually disables all the
- *       subscription filters that publish to it. This operation does not delete the
- *       physical resource encapsulated by the destination.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, DeleteDestinationCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, DeleteDestinationCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new DeleteDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDestinationCommandInput} for command's `input` shape.
- * @see {@link DeleteDestinationCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDestinationCommand extends $Command<DeleteDestinationCommandInput, DeleteDestinationCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: DeleteDestinationCommandInput;
     constructor(input: DeleteDestinationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDestinationCommandInput, DeleteDestinationCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,33 +6,11 @@ export interface DeleteQueryDefinitionCommandInput extends DeleteQueryDefinition
 }
 export interface DeleteQueryDefinitionCommandOutput extends DeleteQueryDefinitionResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a saved CloudWatch Logs Insights query definition.
- *       A query definition contains details about a saved CloudWatch Logs Insights query.</p>
- *          <p>Each <code>DeleteQueryDefinition</code> operation can delete one query definition.</p>
- *          <p>You must have the <code>logs:DeleteQueryDefinition</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, DeleteQueryDefinitionCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, DeleteQueryDefinitionCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new DeleteQueryDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteQueryDefinitionCommandInput} for command's `input` shape.
- * @see {@link DeleteQueryDefinitionCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteQueryDefinitionCommand extends $Command<DeleteQueryDefinitionCommandInput, DeleteQueryDefinitionCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: DeleteQueryDefinitionCommandInput;
     constructor(input: DeleteQueryDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteQueryDefinitionCommandInput, DeleteQueryDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteResourcePolicyCommandInput extends DeleteResourcePolicyRe
 }
 export interface DeleteResourcePolicyCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes a resource policy from this account. This revokes
- *     the access of the identities in that policy to put log events to this account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, DeleteResourcePolicyCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, DeleteResourcePolicyCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new DeleteResourcePolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteResourcePolicyCommandInput} for command's `input` shape.
- * @see {@link DeleteResourcePolicyCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteResourcePolicyCommand extends $Command<DeleteResourcePolicyCommandInput, DeleteResourcePolicyCommandOutput, CloudWatchLogsClientResolvedConfig> {
     readonly input: DeleteResourcePolicyCommandInput;
     constructor(input: DeleteResourcePolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudWatchLogsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteResourcePolicyCommandInput, DeleteResourcePolicyCommandOutput>;
     private serialize;
     private deserialize;