@aws-sdk/client-cloudwatch-logs 3.34.0 → 3.35.0

package/dist/types/commands/DeleteQueryDefinitionCommand.d.ts

@@ -1,39 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DeleteQueryDefinitionRequest, DeleteQueryDefinitionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteQueryDefinitionCommandInput extends DeleteQueryDefinitionRequest {
-}
-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/commands/DeleteResourcePolicyCommand.d.ts

@@ -1,36 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DeleteResourcePolicyRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteResourcePolicyCommandInput extends DeleteResourcePolicyRequest {
-}
-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;
-}

package/dist/types/commands/DeleteRetentionPolicyCommand.d.ts

@@ -1,36 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DeleteRetentionPolicyRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteRetentionPolicyCommandInput extends DeleteRetentionPolicyRequest {
-}
-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/commands/DeleteSubscriptionFilterCommand.d.ts

@@ -1,35 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DeleteSubscriptionFilterRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteSubscriptionFilterCommandInput extends DeleteSubscriptionFilterRequest {
-}
-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/commands/DescribeDestinationsCommand.d.ts

@@ -1,35 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DescribeDestinationsRequest, DescribeDestinationsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDestinationsCommandInput extends DescribeDestinationsRequest {
-}
-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/commands/DescribeExportTasksCommand.d.ts

@@ -1,36 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DescribeExportTasksRequest, DescribeExportTasksResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeExportTasksCommandInput extends DescribeExportTasksRequest {
-}
-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/commands/DescribeLogGroupsCommand.d.ts

@@ -1,43 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DescribeLogGroupsRequest, DescribeLogGroupsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/DescribeLogStreamsCommand.d.ts

@@ -1,38 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DescribeLogStreamsRequest, DescribeLogStreamsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeLogStreamsCommandInput extends DescribeLogStreamsRequest {
-}
-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/commands/DescribeMetricFiltersCommand.d.ts

@@ -1,37 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DescribeMetricFiltersRequest, DescribeMetricFiltersResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeMetricFiltersCommandInput extends DescribeMetricFiltersRequest {
-}
-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/commands/DescribeQueriesCommand.d.ts

@@ -1,37 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DescribeQueriesRequest, DescribeQueriesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/DescribeQueryDefinitionsCommand.d.ts

@@ -1,37 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DescribeQueryDefinitionsRequest, DescribeQueryDefinitionsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeQueryDefinitionsCommandInput extends DescribeQueryDefinitionsRequest {
-}
-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/commands/DescribeResourcePoliciesCommand.d.ts

@@ -1,35 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DescribeResourcePoliciesRequest, DescribeResourcePoliciesResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeResourcePoliciesCommandInput extends DescribeResourcePoliciesRequest {
-}
-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/commands/DescribeSubscriptionFiltersCommand.d.ts

@@ -1,36 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DescribeSubscriptionFiltersRequest, DescribeSubscriptionFiltersResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeSubscriptionFiltersCommandInput extends DescribeSubscriptionFiltersRequest {
-}
-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/commands/DisassociateKmsKeyCommand.d.ts

@@ -1,38 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DisassociateKmsKeyRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DisassociateKmsKeyCommandInput extends DisassociateKmsKeyRequest {
-}
-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/commands/FilterLogEventsCommand.d.ts

@@ -1,43 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { FilterLogEventsRequest, FilterLogEventsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/GetLogEventsCommand.d.ts

@@ -1,40 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { GetLogEventsRequest, GetLogEventsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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;
-}