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

package/src/commands/CreateExportTaskCommand.ts

@@ -0,0 +1,108 @@
+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 { CreateExportTaskRequest, CreateExportTaskResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1CreateExportTaskCommand,
+  serializeAws_json1_1CreateExportTaskCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface CreateExportTaskCommandInput extends CreateExportTaskRequest {}
+export interface CreateExportTaskCommandOutput extends CreateExportTaskResponse, __MetadataBearer {}
+
+/**
+ * <p>Creates an export task, which allows you to efficiently export data from a
+ *       log group to an Amazon S3 bucket. When you perform a <code>CreateExportTask</code>
+ *       operation, you must use credentials that have permission to write to the S3 bucket
+ *       that you specify as the destination.</p>
+ *          <p>This is an asynchronous call. If all the required information is provided, this
+ *       operation initiates an export task and responds with the ID of the task. After the task has started,
+ *       you can use <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeExportTasks.html">DescribeExportTasks</a> to get the status of the export task. Each account can
+ *       only have one active (<code>RUNNING</code> or <code>PENDING</code>) export task at a time.
+ *       To cancel an export task, use <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CancelExportTask.html">CancelExportTask</a>.</p>
+ *          <p>You can export logs from multiple log groups or multiple time ranges to the same S3
+ *       bucket. To separate out log data for each export task, you can specify a prefix to be used as
+ *       the Amazon S3 key prefix for all exported objects.</p>
+ *          <p>Exporting to S3 buckets that are encrypted with AES-256 is supported. Exporting to S3 buckets
+ *       encrypted with SSE-KMS is not supported. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, CreateExportTaskCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, CreateExportTaskCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new CreateExportTaskCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateExportTaskCommandInput} for command's `input` shape.
+ * @see {@link CreateExportTaskCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class CreateExportTaskCommand extends $Command<
+  CreateExportTaskCommandInput,
+  CreateExportTaskCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateExportTaskCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateExportTaskCommandInput, CreateExportTaskCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "CreateExportTaskCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateExportTaskRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateExportTaskResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateExportTaskCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1CreateExportTaskCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateExportTaskCommandOutput> {
+    return deserializeAws_json1_1CreateExportTaskCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreateLogGroupCommand.ts

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

package/src/commands/CreateLogStreamCommand.ts

@@ -0,0 +1,111 @@
+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 { CreateLogStreamRequest } from "../models/models_0";
+import {
+  deserializeAws_json1_1CreateLogStreamCommand,
+  serializeAws_json1_1CreateLogStreamCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface CreateLogStreamCommandInput extends CreateLogStreamRequest {}
+export interface CreateLogStreamCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Creates a log stream for the specified log group. A log stream is a sequence of log events
+ *       that originate from a single source, such as an application instance or a resource that is
+ *       being monitored.</p>
+ *          <p>There is no limit on the number of log streams that you can create for a log group. There is a limit
+ *     of 50 TPS on <code>CreateLogStream</code> operations, after which transactions are throttled.</p>
+ *          <p>You must use the following guidelines when naming a log stream:</p>
+ *          <ul>
+ *             <li>
+ *                <p>Log stream names must be unique within the log group.</p>
+ *             </li>
+ *             <li>
+ *                <p>Log stream names can be between 1 and 512 characters long.</p>
+ *             </li>
+ *             <li>
+ *                <p>The ':' (colon) and '*' (asterisk) characters are not allowed.</p>
+ *             </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, CreateLogStreamCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, CreateLogStreamCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new CreateLogStreamCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateLogStreamCommandInput} for command's `input` shape.
+ * @see {@link CreateLogStreamCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class CreateLogStreamCommand extends $Command<
+  CreateLogStreamCommandInput,
+  CreateLogStreamCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateLogStreamCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateLogStreamCommandInput, CreateLogStreamCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "CreateLogStreamCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateLogStreamRequest.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: CreateLogStreamCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1CreateLogStreamCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateLogStreamCommandOutput> {
+    return deserializeAws_json1_1CreateLogStreamCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/DeleteDestinationCommand.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 { DeleteDestinationRequest } from "../models/models_0";
+import {
+  deserializeAws_json1_1DeleteDestinationCommand,
+  serializeAws_json1_1DeleteDestinationCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface DeleteDestinationCommandInput extends DeleteDestinationRequest {}
+export interface DeleteDestinationCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Deletes the specified destination, and eventually disables all the
+ *       subscription filters that publish to it. This operation does not delete the
+ *       physical resource encapsulated by the destination.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, DeleteDestinationCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, DeleteDestinationCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new DeleteDestinationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDestinationCommandInput} for command's `input` shape.
+ * @see {@link DeleteDestinationCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class DeleteDestinationCommand extends $Command<
+  DeleteDestinationCommandInput,
+  DeleteDestinationCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: DeleteDestinationCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<DeleteDestinationCommandInput, DeleteDestinationCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "DeleteDestinationCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: DeleteDestinationRequest.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: DeleteDestinationCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1DeleteDestinationCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteDestinationCommandOutput> {
+    return deserializeAws_json1_1DeleteDestinationCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/DeleteLogGroupCommand.ts

@@ -0,0 +1,96 @@
+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 { DeleteLogGroupRequest } from "../models/models_0";
+import {
+  deserializeAws_json1_1DeleteLogGroupCommand,
+  serializeAws_json1_1DeleteLogGroupCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface DeleteLogGroupCommandInput extends DeleteLogGroupRequest {}
+export interface DeleteLogGroupCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Deletes the specified log group and permanently deletes all the archived
+ *       log events associated with the log group.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, DeleteLogGroupCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, DeleteLogGroupCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new DeleteLogGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteLogGroupCommandInput} for command's `input` shape.
+ * @see {@link DeleteLogGroupCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class DeleteLogGroupCommand extends $Command<
+  DeleteLogGroupCommandInput,
+  DeleteLogGroupCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: DeleteLogGroupCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<DeleteLogGroupCommandInput, DeleteLogGroupCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "DeleteLogGroupCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: DeleteLogGroupRequest.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: DeleteLogGroupCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1DeleteLogGroupCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteLogGroupCommandOutput> {
+    return deserializeAws_json1_1DeleteLogGroupCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/DeleteLogStreamCommand.ts

@@ -0,0 +1,96 @@
+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 { DeleteLogStreamRequest } from "../models/models_0";
+import {
+  deserializeAws_json1_1DeleteLogStreamCommand,
+  serializeAws_json1_1DeleteLogStreamCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface DeleteLogStreamCommandInput extends DeleteLogStreamRequest {}
+export interface DeleteLogStreamCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Deletes the specified log stream and permanently deletes all the archived log events associated
+ *       with the log stream.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, DeleteLogStreamCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, DeleteLogStreamCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new DeleteLogStreamCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteLogStreamCommandInput} for command's `input` shape.
+ * @see {@link DeleteLogStreamCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class DeleteLogStreamCommand extends $Command<
+  DeleteLogStreamCommandInput,
+  DeleteLogStreamCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: DeleteLogStreamCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<DeleteLogStreamCommandInput, DeleteLogStreamCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "DeleteLogStreamCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: DeleteLogStreamRequest.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: DeleteLogStreamCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1DeleteLogStreamCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteLogStreamCommandOutput> {
+    return deserializeAws_json1_1DeleteLogStreamCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}