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

package/src/commands/PutQueryDefinitionCommand.ts

@@ -0,0 +1,106 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+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";
+
+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
+}

package/src/commands/PutResourcePolicyCommand.ts

@@ -0,0 +1,97 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { PutResourcePolicyRequest, PutResourcePolicyResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1PutResourcePolicyCommand,
+  serializeAws_json1_1PutResourcePolicyCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface PutResourcePolicyCommandInput extends PutResourcePolicyRequest {}
+export interface PutResourcePolicyCommandOutput extends PutResourcePolicyResponse, __MetadataBearer {}
+
+/**
+ * <p>Creates or updates a resource policy allowing other Amazon Web Services services to put log events to
+ *       this account, such as Amazon Route 53. An account can have up to 10 resource policies per Amazon Web Services
+ *       Region.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, PutResourcePolicyCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, PutResourcePolicyCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new PutResourcePolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutResourcePolicyCommandInput} for command's `input` shape.
+ * @see {@link PutResourcePolicyCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class PutResourcePolicyCommand extends $Command<
+  PutResourcePolicyCommandInput,
+  PutResourcePolicyCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: PutResourcePolicyCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<PutResourcePolicyCommandInput, PutResourcePolicyCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "PutResourcePolicyCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: PutResourcePolicyRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: PutResourcePolicyResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: PutResourcePolicyCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1PutResourcePolicyCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutResourcePolicyCommandOutput> {
+    return deserializeAws_json1_1PutResourcePolicyCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/PutRetentionPolicyCommand.ts

@@ -0,0 +1,97 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { PutRetentionPolicyRequest } from "../models/models_0";
+import {
+  deserializeAws_json1_1PutRetentionPolicyCommand,
+  serializeAws_json1_1PutRetentionPolicyCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface PutRetentionPolicyCommandInput extends PutRetentionPolicyRequest {}
+export interface PutRetentionPolicyCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Sets the retention of the specified log group. A retention policy allows you to
+ *       configure the number of days for which to retain log events in the specified log
+ *       group.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, PutRetentionPolicyCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, PutRetentionPolicyCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new PutRetentionPolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutRetentionPolicyCommandInput} for command's `input` shape.
+ * @see {@link PutRetentionPolicyCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class PutRetentionPolicyCommand extends $Command<
+  PutRetentionPolicyCommandInput,
+  PutRetentionPolicyCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: PutRetentionPolicyCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<PutRetentionPolicyCommandInput, PutRetentionPolicyCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "PutRetentionPolicyCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: PutRetentionPolicyRequest.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: PutRetentionPolicyCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1PutRetentionPolicyCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutRetentionPolicyCommandOutput> {
+    return deserializeAws_json1_1PutRetentionPolicyCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/PutSubscriptionFilterCommand.ts

@@ -0,0 +1,123 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { PutSubscriptionFilterRequest } from "../models/models_0";
+import {
+  deserializeAws_json1_1PutSubscriptionFilterCommand,
+  serializeAws_json1_1PutSubscriptionFilterCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface PutSubscriptionFilterCommandInput extends PutSubscriptionFilterRequest {}
+export interface PutSubscriptionFilterCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Creates or updates a subscription filter and associates it with the specified log
+ *       group. Subscription filters allow you to subscribe to a real-time stream of log events
+ *       ingested through <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html">PutLogEvents</a> and have them delivered to a specific
+ *       destination. When log events are sent to the
+ *       receiving service, they are Base64 encoded
+ *       and compressed with the gzip format.</p>
+ *          <p>The following destinations are supported for subscription filters:</p>
+ *          <ul>
+ *             <li>
+ *                <p>An Amazon Kinesis stream belonging to the same account as the subscription filter,
+ *           for same-account delivery.</p>
+ *             </li>
+ *             <li>
+ *                <p>A logical destination that belongs to a different account, for cross-account delivery.</p>
+ *             </li>
+ *             <li>
+ *                <p>An Amazon Kinesis Firehose delivery stream that belongs to the same account as the
+ *           subscription filter, for same-account delivery.</p>
+ *             </li>
+ *             <li>
+ *                <p>An Lambda function that belongs to the same account as the subscription filter,
+ *           for same-account delivery.</p>
+ *             </li>
+ *          </ul>
+ *          <p>Each log group can have up to two subscription filters associated with it. If you are
+ *       updating an existing filter, you must specify the correct name in <code>filterName</code>.
+ *       </p>
+ *          <p>To perform a <code>PutSubscriptionFilter</code> operation, you must also have the
+ *       <code>iam:PassRole</code> permission.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, PutSubscriptionFilterCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, PutSubscriptionFilterCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new PutSubscriptionFilterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutSubscriptionFilterCommandInput} for command's `input` shape.
+ * @see {@link PutSubscriptionFilterCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class PutSubscriptionFilterCommand extends $Command<
+  PutSubscriptionFilterCommandInput,
+  PutSubscriptionFilterCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: PutSubscriptionFilterCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<PutSubscriptionFilterCommandInput, PutSubscriptionFilterCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "PutSubscriptionFilterCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: PutSubscriptionFilterRequest.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: PutSubscriptionFilterCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1PutSubscriptionFilterCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutSubscriptionFilterCommandOutput> {
+    return deserializeAws_json1_1PutSubscriptionFilterCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/StartQueryCommand.ts

@@ -0,0 +1,100 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { StartQueryRequest, StartQueryResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1StartQueryCommand,
+  serializeAws_json1_1StartQueryCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface StartQueryCommandInput extends StartQueryRequest {}
+export interface StartQueryCommandOutput extends StartQueryResponse, __MetadataBearer {}
+
+/**
+ * <p>Schedules a query of a log group using CloudWatch Logs Insights. You specify the log group
+ *       and time range to query and the query string to use.</p>
+ *          <p>For more information, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html">CloudWatch Logs Insights Query Syntax</a>.</p>
+ *
+ *          <p>Queries time out after 15 minutes of execution. If your queries are timing out, reduce the
+ *       time range being searched or partition your query into a number of queries.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, StartQueryCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, StartQueryCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new StartQueryCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartQueryCommandInput} for command's `input` shape.
+ * @see {@link StartQueryCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class StartQueryCommand extends $Command<
+  StartQueryCommandInput,
+  StartQueryCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: StartQueryCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<StartQueryCommandInput, StartQueryCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "StartQueryCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: StartQueryRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: StartQueryResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: StartQueryCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1StartQueryCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<StartQueryCommandOutput> {
+    return deserializeAws_json1_1StartQueryCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/StopQueryCommand.ts

@@ -0,0 +1,93 @@
+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,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { StopQueryRequest, StopQueryResponse } from "../models/models_0";
+import { deserializeAws_json1_1StopQueryCommand, serializeAws_json1_1StopQueryCommand } from "../protocols/Aws_json1_1";
+
+export interface StopQueryCommandInput extends StopQueryRequest {}
+export interface StopQueryCommandOutput extends StopQueryResponse, __MetadataBearer {}
+
+/**
+ * <p>Stops a CloudWatch Logs Insights query that is in progress. If the query has already ended, the operation
+ *     returns an error indicating that the specified query is not running.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, StopQueryCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, StopQueryCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new StopQueryCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StopQueryCommandInput} for command's `input` shape.
+ * @see {@link StopQueryCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class StopQueryCommand extends $Command<
+  StopQueryCommandInput,
+  StopQueryCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: StopQueryCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<StopQueryCommandInput, StopQueryCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "StopQueryCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: StopQueryRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: StopQueryResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: StopQueryCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1StopQueryCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<StopQueryCommandOutput> {
+    return deserializeAws_json1_1StopQueryCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}