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

package/commands/ListTagsLogGroupCommand.ts

@@ -1,94 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { ListTagsLogGroupRequest, ListTagsLogGroupResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1ListTagsLogGroupCommand,
-  serializeAws_json1_1ListTagsLogGroupCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface ListTagsLogGroupCommandInput extends ListTagsLogGroupRequest {}
-export interface ListTagsLogGroupCommandOutput extends ListTagsLogGroupResponse, __MetadataBearer {}
-
-/**
- * <p>Lists the tags for the specified log group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, ListTagsLogGroupCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, ListTagsLogGroupCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new ListTagsLogGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsLogGroupCommandInput} for command's `input` shape.
- * @see {@link ListTagsLogGroupCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class ListTagsLogGroupCommand extends $Command<
-  ListTagsLogGroupCommandInput,
-  ListTagsLogGroupCommandOutput,
-  CloudWatchLogsClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: ListTagsLogGroupCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudWatchLogsClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ListTagsLogGroupCommandInput, ListTagsLogGroupCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudWatchLogsClient";
-    const commandName = "ListTagsLogGroupCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: ListTagsLogGroupRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: ListTagsLogGroupResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: ListTagsLogGroupCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1ListTagsLogGroupCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListTagsLogGroupCommandOutput> {
-    return deserializeAws_json1_1ListTagsLogGroupCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/PutDestinationCommand.ts

@@ -1,103 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { PutDestinationRequest, PutDestinationResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1PutDestinationCommand,
-  serializeAws_json1_1PutDestinationCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface PutDestinationCommandInput extends PutDestinationRequest {}
-export interface PutDestinationCommandOutput extends PutDestinationResponse, __MetadataBearer {}
-
-/**
- * <p>Creates or updates a destination. This operation is used only to create destinations for cross-account subscriptions.</p>
- *          <p>A destination encapsulates a physical resource (such
- *       as an Amazon Kinesis stream) and enables you to subscribe to a real-time stream of log events
- *       for a different account, ingested using <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html">PutLogEvents</a>.</p>
- *          <p>Through an access policy, a destination controls what is written to it.
- *       By default, <code>PutDestination</code> does not set any access policy with the destination,
- *       which means a cross-account user cannot call <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutSubscriptionFilter.html">PutSubscriptionFilter</a> against
- *       this destination. To enable this, the destination owner must call <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutDestinationPolicy.html">PutDestinationPolicy</a> after <code>PutDestination</code>.</p>
- *          <p>To perform a <code>PutDestination</code> operation, you must also have the
- *     <code>iam:PassRole</code> permission.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, PutDestinationCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, PutDestinationCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new PutDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutDestinationCommandInput} for command's `input` shape.
- * @see {@link PutDestinationCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class PutDestinationCommand extends $Command<
-  PutDestinationCommandInput,
-  PutDestinationCommandOutput,
-  CloudWatchLogsClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: PutDestinationCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudWatchLogsClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PutDestinationCommandInput, PutDestinationCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudWatchLogsClient";
-    const commandName = "PutDestinationCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: PutDestinationRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: PutDestinationResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: PutDestinationCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1PutDestinationCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutDestinationCommandOutput> {
-    return deserializeAws_json1_1PutDestinationCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/PutDestinationPolicyCommand.ts

@@ -1,99 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { PutDestinationPolicyRequest } from "../models/models_0";
-import {
-  deserializeAws_json1_1PutDestinationPolicyCommand,
-  serializeAws_json1_1PutDestinationPolicyCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface PutDestinationPolicyCommandInput extends PutDestinationPolicyRequest {}
-export interface PutDestinationPolicyCommandOutput extends __MetadataBearer {}
-
-/**
- * <p>Creates or updates an access policy associated with an existing
- *       destination. An access policy is an <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies_overview.html">IAM policy document</a> that is used
- *       to authorize claims to register a subscription filter against a given destination.</p>
- *          <p>If multiple Amazon Web Services accounts are sending logs to this destination, each sender account must be
- *     listed separately in the policy. The policy does not support specifying <code>*</code>
- *     as the Principal or the use of the <code>aws:PrincipalOrgId</code> global key.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, PutDestinationPolicyCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, PutDestinationPolicyCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new PutDestinationPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutDestinationPolicyCommandInput} for command's `input` shape.
- * @see {@link PutDestinationPolicyCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class PutDestinationPolicyCommand extends $Command<
-  PutDestinationPolicyCommandInput,
-  PutDestinationPolicyCommandOutput,
-  CloudWatchLogsClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: PutDestinationPolicyCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudWatchLogsClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PutDestinationPolicyCommandInput, PutDestinationPolicyCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudWatchLogsClient";
-    const commandName = "PutDestinationPolicyCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: PutDestinationPolicyRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: (output: any) => output,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: PutDestinationPolicyCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1PutDestinationPolicyCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutDestinationPolicyCommandOutput> {
-    return deserializeAws_json1_1PutDestinationPolicyCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/PutLogEventsCommand.ts

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

package/commands/PutMetricFilterCommand.ts

@@ -1,116 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { PutMetricFilterRequest } from "../models/models_0";
-import {
-  deserializeAws_json1_1PutMetricFilterCommand,
-  serializeAws_json1_1PutMetricFilterCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface PutMetricFilterCommandInput extends PutMetricFilterRequest {}
-export interface PutMetricFilterCommandOutput extends __MetadataBearer {}
-
-/**
- * <p>Creates or updates a metric filter and associates it with the specified log group.
- *       Metric filters allow you to configure rules to extract metric data from log events ingested
- *       through <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html">PutLogEvents</a>.</p>
- *          <p>The maximum number of metric filters that can be associated with a log group is
- *       100.</p>
- *          <p>When you create a metric filter, you can also optionally assign a unit and dimensions
- *     to the metric that is created.</p>
- *          <important>
- *             <p>Metrics extracted from log events are charged as custom metrics.
- *       To prevent unexpected high charges, do not specify high-cardinality fields such as
- *       <code>IPAddress</code> or <code>requestID</code> as dimensions. Each different value
- *       found for
- *       a dimension is treated as a separate metric and accrues charges as a separate custom metric.
- *     </p>
- *             <p>To help prevent accidental high charges, Amazon disables a metric filter
- *         if it generates 1000 different name/value pairs for the dimensions that you
- *         have specified within a certain amount of time.</p>
- *             <p>You can also set up a billing alarm to alert you if your charges are higher than
- *         expected. For more information,
- *         see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/monitor_estimated_charges_with_cloudwatch.html">
- *           Creating a Billing Alarm to Monitor Your Estimated Amazon Web Services Charges</a>.
- *       </p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, PutMetricFilterCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, PutMetricFilterCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new PutMetricFilterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutMetricFilterCommandInput} for command's `input` shape.
- * @see {@link PutMetricFilterCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class PutMetricFilterCommand extends $Command<
-  PutMetricFilterCommandInput,
-  PutMetricFilterCommandOutput,
-  CloudWatchLogsClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: PutMetricFilterCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudWatchLogsClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PutMetricFilterCommandInput, PutMetricFilterCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudWatchLogsClient";
-    const commandName = "PutMetricFilterCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: PutMetricFilterRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: (output: any) => output,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: PutMetricFilterCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1PutMetricFilterCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutMetricFilterCommandOutput> {
-    return deserializeAws_json1_1PutMetricFilterCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/PutQueryDefinitionCommand.ts

@@ -1,105 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { PutQueryDefinitionRequest, PutQueryDefinitionResponse } from "../models/models_0";
-import {
-  deserializeAws_json1_1PutQueryDefinitionCommand,
-  serializeAws_json1_1PutQueryDefinitionCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface PutQueryDefinitionCommandInput extends PutQueryDefinitionRequest {}
-export interface PutQueryDefinitionCommandOutput extends PutQueryDefinitionResponse, __MetadataBearer {}
-
-/**
- * <p>Creates or updates a query definition for CloudWatch Logs Insights. For
- *       more information, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html">Analyzing Log Data with CloudWatch Logs Insights</a>.</p>
- *
- *          <p>To update a query definition, specify its
- *         <code>queryDefinitionId</code> in your request. The values of <code>name</code>, <code>queryString</code>,
- *       and <code>logGroupNames</code> are changed to the values that you specify in your update
- *       operation. No current values are retained from the current query definition. For example, if
- *       you update a current query definition that includes log groups, and you don't specify the
- *         <code>logGroupNames</code> parameter in your update operation, the query definition changes
- *       to contain no log groups.</p>
- *          <p>You must have the <code>logs:PutQueryDefinition</code> permission to be able to perform
- *     this operation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudWatchLogsClient, PutQueryDefinitionCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
- * // const { CloudWatchLogsClient, PutQueryDefinitionCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
- * const client = new CloudWatchLogsClient(config);
- * const command = new PutQueryDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutQueryDefinitionCommandInput} for command's `input` shape.
- * @see {@link PutQueryDefinitionCommandOutput} for command's `response` shape.
- * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class PutQueryDefinitionCommand extends $Command<
-  PutQueryDefinitionCommandInput,
-  PutQueryDefinitionCommandOutput,
-  CloudWatchLogsClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: PutQueryDefinitionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudWatchLogsClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PutQueryDefinitionCommandInput, PutQueryDefinitionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudWatchLogsClient";
-    const commandName = "PutQueryDefinitionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: PutQueryDefinitionRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: PutQueryDefinitionResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: PutQueryDefinitionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1PutQueryDefinitionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutQueryDefinitionCommandOutput> {
-    return deserializeAws_json1_1PutQueryDefinitionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}