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

package/commands/CreateExportTaskCommand.ts

@@ -1,107 +0,0 @@
-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";
-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 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/commands/CreateLogGroupCommand.ts

@@ -1,120 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { CreateLogGroupRequest } from "../models/models_0";
-import {
-  deserializeAws_json1_1CreateLogGroupCommand,
-  serializeAws_json1_1CreateLogGroupCommand,
-} 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 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/commands/CreateLogStreamCommand.ts

@@ -1,110 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { CreateLogStreamRequest } from "../models/models_0";
-import {
-  deserializeAws_json1_1CreateLogStreamCommand,
-  serializeAws_json1_1CreateLogStreamCommand,
-} 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 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/commands/DeleteDestinationCommand.ts

@@ -1,96 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DeleteDestinationRequest } from "../models/models_0";
-import {
-  deserializeAws_json1_1DeleteDestinationCommand,
-  serializeAws_json1_1DeleteDestinationCommand,
-} 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 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/commands/DeleteLogGroupCommand.ts

@@ -1,95 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DeleteLogGroupRequest } from "../models/models_0";
-import {
-  deserializeAws_json1_1DeleteLogGroupCommand,
-  serializeAws_json1_1DeleteLogGroupCommand,
-} 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 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/commands/DeleteLogStreamCommand.ts

@@ -1,95 +0,0 @@
-import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
-import { DeleteLogStreamRequest } from "../models/models_0";
-import {
-  deserializeAws_json1_1DeleteLogStreamCommand,
-  serializeAws_json1_1DeleteLogStreamCommand,
-} 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 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
-}