@aws-sdk/client-dynamodb 3.34.0 → 3.35.0

package/commands/DescribeLimitsCommand.ts

@@ -1,157 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeLimitsInput, DescribeLimitsOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0DescribeLimitsCommand,
-  serializeAws_json1_0DescribeLimitsCommand,
-} from "../protocols/Aws_json1_0";
-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 DescribeLimitsCommandInput extends DescribeLimitsInput {}
-export interface DescribeLimitsCommandOutput extends DescribeLimitsOutput, __MetadataBearer {}
-
-/**
- * <p>Returns the current provisioned-capacity quotas for your AWS account in a Region, both
- *             for the Region as a whole and for any one DynamoDB table that you create there.</p>
- *          <p>When you establish an AWS account, the account has initial quotas on the maximum read
- *             capacity units and write capacity units that you can provision across all of your
- *             DynamoDB tables in a given Region. Also, there are per-table quotas that apply when you
- *             create a table there. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Service, Account, and Table
- *                 Quotas</a> page in the <i>Amazon DynamoDB Developer
- *             Guide</i>.</p>
- *
- *          <p>Although you can increase these quotas by filing a case at <a href="https://console.aws.amazon.com/support/home#/">AWS Support Center</a>, obtaining the increase is not
- *             instantaneous. The <code>DescribeLimits</code> action lets you write code to compare the
- *             capacity you are currently using to those quotas imposed by your account so that you
- *             have enough time to apply for an increase before you hit a quota.</p>
- *
- *          <p>For example, you could use one of the AWS SDKs to do the following:</p>
- *
- *          <ol>
- *             <li>
- *                <p>Call <code>DescribeLimits</code> for a particular Region to obtain your current
- *                     account quotas on provisioned capacity there.</p>
- *             </li>
- *             <li>
- *                <p>Create a variable to hold the aggregate read capacity units provisioned for all
- *                     your tables in that Region, and one to hold the aggregate write capacity units.
- *                     Zero them both.</p>
- *             </li>
- *             <li>
- *                <p>Call <code>ListTables</code> to obtain a list of all your DynamoDB tables.</p>
- *             </li>
- *             <li>
- *                <p>For each table name listed by <code>ListTables</code>, do the following:</p>
- *                <ul>
- *                   <li>
- *                      <p>Call <code>DescribeTable</code> with the table name.</p>
- *                   </li>
- *                   <li>
- *                      <p>Use the data returned by <code>DescribeTable</code> to add the read capacity units and write capacity
- *             units provisioned for the table itself to your variables.</p>
- *                   </li>
- *                   <li>
- *                      <p>If the table has one or more global secondary indexes (GSIs), loop over these GSIs and add their provisioned capacity values to your variables as well.</p>
- *                   </li>
- *                </ul>
- *             </li>
- *             <li>
- *                <p>Report the account quotas for that Region returned by <code>DescribeLimits</code>, along with
- *                     the total current provisioned capacity levels you have calculated.</p>
- *             </li>
- *          </ol>
- *
- *          <p>This will let you see whether you are getting close to your account-level quotas.</p>
- *          <p>The per-table quotas apply only when you are creating a new table. They restrict the sum
- *             of the provisioned capacity of the new table itself and all its global secondary
- *             indexes.</p>
- *          <p>For existing tables and their GSIs, DynamoDB doesn't let you increase provisioned
- *             capacity extremely rapidly, but the only quota that applies is that the aggregate
- *             provisioned capacity over all your tables and GSIs cannot exceed either of the
- *             per-account quotas.</p>
- *          <note>
- *             <p>
- *                <code>DescribeLimits</code> should only be called periodically. You can expect throttling
- *         errors if you call it more than once in a minute.</p>
- *          </note>
- *          <p>The <code>DescribeLimits</code> Request element has no content.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DescribeLimitsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeLimitsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeLimitsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLimitsCommandInput} for command's `input` shape.
- * @see {@link DescribeLimitsCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DescribeLimitsCommand extends $Command<
-  DescribeLimitsCommandInput,
-  DescribeLimitsCommandOutput,
-  DynamoDBClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DescribeLimitsCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DynamoDBClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DescribeLimitsCommandInput, DescribeLimitsCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DynamoDBClient";
-    const commandName = "DescribeLimitsCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DescribeLimitsInput.filterSensitiveLog,
-      outputFilterSensitiveLog: DescribeLimitsOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DescribeLimitsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_0DescribeLimitsCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DescribeLimitsCommandOutput> {
-    return deserializeAws_json1_0DescribeLimitsCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DescribeTableCommand.ts

@@ -1,100 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeTableInput, DescribeTableOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0DescribeTableCommand,
-  serializeAws_json1_0DescribeTableCommand,
-} from "../protocols/Aws_json1_0";
-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 DescribeTableCommandInput extends DescribeTableInput {}
-export interface DescribeTableCommandOutput extends DescribeTableOutput, __MetadataBearer {}
-
-/**
- * <p>Returns information about the table, including the current status of the table, when it was created, the primary key schema, and any indexes on the table.</p>
- *          <note>
- *             <p>If you issue a <code>DescribeTable</code> request immediately after a <code>CreateTable</code> request, DynamoDB might
- *         return a <code>ResourceNotFoundException</code>. This is because <code>DescribeTable</code> uses an eventually
- *         consistent query, and the metadata for your table might not be available at that moment.
- *         Wait for a few seconds, and then try the <code>DescribeTable</code> request again.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DescribeTableCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeTableCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeTableCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTableCommandInput} for command's `input` shape.
- * @see {@link DescribeTableCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DescribeTableCommand extends $Command<
-  DescribeTableCommandInput,
-  DescribeTableCommandOutput,
-  DynamoDBClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DescribeTableCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DynamoDBClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DescribeTableCommandInput, DescribeTableCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DynamoDBClient";
-    const commandName = "DescribeTableCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DescribeTableInput.filterSensitiveLog,
-      outputFilterSensitiveLog: DescribeTableOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DescribeTableCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_0DescribeTableCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DescribeTableCommandOutput> {
-    return deserializeAws_json1_0DescribeTableCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DescribeTableReplicaAutoScalingCommand.ts

@@ -1,105 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeTableReplicaAutoScalingInput, DescribeTableReplicaAutoScalingOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0DescribeTableReplicaAutoScalingCommand,
-  serializeAws_json1_0DescribeTableReplicaAutoScalingCommand,
-} from "../protocols/Aws_json1_0";
-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 DescribeTableReplicaAutoScalingCommandInput extends DescribeTableReplicaAutoScalingInput {}
-export interface DescribeTableReplicaAutoScalingCommandOutput
-  extends DescribeTableReplicaAutoScalingOutput,
-    __MetadataBearer {}
-
-/**
- * <p>Describes auto scaling settings across replicas of the global table at once.</p>
- *          <note>
- *             <p>This operation only applies to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21</a> of global tables.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DescribeTableReplicaAutoScalingCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeTableReplicaAutoScalingCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeTableReplicaAutoScalingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTableReplicaAutoScalingCommandInput} for command's `input` shape.
- * @see {@link DescribeTableReplicaAutoScalingCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DescribeTableReplicaAutoScalingCommand extends $Command<
-  DescribeTableReplicaAutoScalingCommandInput,
-  DescribeTableReplicaAutoScalingCommandOutput,
-  DynamoDBClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DescribeTableReplicaAutoScalingCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DynamoDBClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DescribeTableReplicaAutoScalingCommandInput, DescribeTableReplicaAutoScalingCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DynamoDBClient";
-    const commandName = "DescribeTableReplicaAutoScalingCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DescribeTableReplicaAutoScalingInput.filterSensitiveLog,
-      outputFilterSensitiveLog: DescribeTableReplicaAutoScalingOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: DescribeTableReplicaAutoScalingCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_json1_0DescribeTableReplicaAutoScalingCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<DescribeTableReplicaAutoScalingCommandOutput> {
-    return deserializeAws_json1_0DescribeTableReplicaAutoScalingCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DescribeTimeToLiveCommand.ts

@@ -1,94 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeTimeToLiveInput, DescribeTimeToLiveOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0DescribeTimeToLiveCommand,
-  serializeAws_json1_0DescribeTimeToLiveCommand,
-} from "../protocols/Aws_json1_0";
-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 DescribeTimeToLiveCommandInput extends DescribeTimeToLiveInput {}
-export interface DescribeTimeToLiveCommandOutput extends DescribeTimeToLiveOutput, __MetadataBearer {}
-
-/**
- * <p>Gives a description of the Time to Live (TTL) status on the specified table. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DescribeTimeToLiveCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeTimeToLiveCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeTimeToLiveCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTimeToLiveCommandInput} for command's `input` shape.
- * @see {@link DescribeTimeToLiveCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DescribeTimeToLiveCommand extends $Command<
-  DescribeTimeToLiveCommandInput,
-  DescribeTimeToLiveCommandOutput,
-  DynamoDBClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DescribeTimeToLiveCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DynamoDBClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DescribeTimeToLiveCommandInput, DescribeTimeToLiveCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DynamoDBClient";
-    const commandName = "DescribeTimeToLiveCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DescribeTimeToLiveInput.filterSensitiveLog,
-      outputFilterSensitiveLog: DescribeTimeToLiveOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DescribeTimeToLiveCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_0DescribeTimeToLiveCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DescribeTimeToLiveCommandOutput> {
-    return deserializeAws_json1_0DescribeTimeToLiveCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DisableKinesisStreamingDestinationCommand.ts

@@ -1,103 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { KinesisStreamingDestinationInput, KinesisStreamingDestinationOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0DisableKinesisStreamingDestinationCommand,
-  serializeAws_json1_0DisableKinesisStreamingDestinationCommand,
-} from "../protocols/Aws_json1_0";
-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 DisableKinesisStreamingDestinationCommandInput extends KinesisStreamingDestinationInput {}
-export interface DisableKinesisStreamingDestinationCommandOutput
-  extends KinesisStreamingDestinationOutput,
-    __MetadataBearer {}
-
-/**
- * <p>Stops replication from the DynamoDB table to the Kinesis data stream. This is done
- *             without deleting either of the resources.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DisableKinesisStreamingDestinationCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DisableKinesisStreamingDestinationCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DisableKinesisStreamingDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableKinesisStreamingDestinationCommandInput} for command's `input` shape.
- * @see {@link DisableKinesisStreamingDestinationCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DisableKinesisStreamingDestinationCommand extends $Command<
-  DisableKinesisStreamingDestinationCommandInput,
-  DisableKinesisStreamingDestinationCommandOutput,
-  DynamoDBClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DisableKinesisStreamingDestinationCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DynamoDBClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DisableKinesisStreamingDestinationCommandInput, DisableKinesisStreamingDestinationCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DynamoDBClient";
-    const commandName = "DisableKinesisStreamingDestinationCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: KinesisStreamingDestinationInput.filterSensitiveLog,
-      outputFilterSensitiveLog: KinesisStreamingDestinationOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: DisableKinesisStreamingDestinationCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_json1_0DisableKinesisStreamingDestinationCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<DisableKinesisStreamingDestinationCommandOutput> {
-    return deserializeAws_json1_0DisableKinesisStreamingDestinationCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/EnableKinesisStreamingDestinationCommand.ts

@@ -1,105 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { KinesisStreamingDestinationInput, KinesisStreamingDestinationOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_0EnableKinesisStreamingDestinationCommand,
-  serializeAws_json1_0EnableKinesisStreamingDestinationCommand,
-} from "../protocols/Aws_json1_0";
-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 EnableKinesisStreamingDestinationCommandInput extends KinesisStreamingDestinationInput {}
-export interface EnableKinesisStreamingDestinationCommandOutput
-  extends KinesisStreamingDestinationOutput,
-    __MetadataBearer {}
-
-/**
- * <p>Starts table data replication to the specified Kinesis data stream at a timestamp chosen
- *             during the enable workflow. If this operation doesn't return results immediately, use
- *             DescribeKinesisStreamingDestination to check if streaming to the Kinesis data stream is
- *             ACTIVE.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, EnableKinesisStreamingDestinationCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, EnableKinesisStreamingDestinationCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new EnableKinesisStreamingDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableKinesisStreamingDestinationCommandInput} for command's `input` shape.
- * @see {@link EnableKinesisStreamingDestinationCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class EnableKinesisStreamingDestinationCommand extends $Command<
-  EnableKinesisStreamingDestinationCommandInput,
-  EnableKinesisStreamingDestinationCommandOutput,
-  DynamoDBClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: EnableKinesisStreamingDestinationCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: DynamoDBClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<EnableKinesisStreamingDestinationCommandInput, EnableKinesisStreamingDestinationCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "DynamoDBClient";
-    const commandName = "EnableKinesisStreamingDestinationCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: KinesisStreamingDestinationInput.filterSensitiveLog,
-      outputFilterSensitiveLog: KinesisStreamingDestinationOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: EnableKinesisStreamingDestinationCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_json1_0EnableKinesisStreamingDestinationCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<EnableKinesisStreamingDestinationCommandOutput> {
-    return deserializeAws_json1_0EnableKinesisStreamingDestinationCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}