@aws-sdk/client-dynamodb 3.34.0 → 3.35.0

package/dist/types/commands/CreateTableCommand.d.ts

@@ -1,47 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { CreateTableInput, CreateTableOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateTableCommandInput extends CreateTableInput {
-}
-export interface CreateTableCommandOutput extends CreateTableOutput, __MetadataBearer {
-}
-/**
- * <p>The <code>CreateTable</code> operation adds a new table to your account. In an AWS
- *             account, table names must be unique within each Region. That is, you can have two tables
- *             with same name if you create the tables in different Regions.</p>
- *          <p>
- *             <code>CreateTable</code> is an asynchronous operation. Upon receiving a <code>CreateTable</code> request,
- *       DynamoDB immediately returns a response with a <code>TableStatus</code> of <code>CREATING</code>. After
- *       the table is created, DynamoDB sets the <code>TableStatus</code> to <code>ACTIVE</code>. You can
- *       perform read and write operations only on an <code>ACTIVE</code> table. </p>
- *          <p>You can optionally define secondary indexes on the new table, as part of the <code>CreateTable</code>
- *       operation. If you want to create multiple tables with secondary indexes on them, you must create the
- *       tables sequentially. Only one table with secondary indexes can be in the <code>CREATING</code> state at
- *       any given time.</p>
- *          <p>You can use the <code>DescribeTable</code> action to check the table status.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, CreateTableCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, CreateTableCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new CreateTableCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTableCommandInput} for command's `input` shape.
- * @see {@link CreateTableCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateTableCommand extends $Command<CreateTableCommandInput, CreateTableCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: CreateTableCommandInput;
-    constructor(input: CreateTableCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTableCommandInput, CreateTableCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteBackupCommand.d.ts

@@ -1,36 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DeleteBackupInput, DeleteBackupOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteBackupCommandInput extends DeleteBackupInput {
-}
-export interface DeleteBackupCommandOutput extends DeleteBackupOutput, __MetadataBearer {
-}
-/**
- * <p>Deletes an existing backup of a table.</p>
- *          <p>You can call <code>DeleteBackup</code> at a maximum rate of 10 times per second.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DeleteBackupCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DeleteBackupCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DeleteBackupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteBackupCommandInput} for command's `input` shape.
- * @see {@link DeleteBackupCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteBackupCommand extends $Command<DeleteBackupCommandInput, DeleteBackupCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: DeleteBackupCommandInput;
-    constructor(input: DeleteBackupCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBackupCommandInput, DeleteBackupCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteItemCommand.d.ts

@@ -1,40 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DeleteItemInput, DeleteItemOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteItemCommandInput extends DeleteItemInput {
-}
-export interface DeleteItemCommandOutput extends DeleteItemOutput, __MetadataBearer {
-}
-/**
- * <p>Deletes a single item in a table by primary key. You can perform a conditional delete operation that deletes the item if it exists, or if it has an expected attribute value.</p>
- *          <p>In addition to deleting an item, you can also return the item's attribute values in the same
- *       operation, using the <code>ReturnValues</code> parameter.</p>
- *          <p>Unless you specify conditions, the <code>DeleteItem</code> is an idempotent operation; running it
- *       multiple times on the same item or attribute does <i>not</i> result in an error response.</p>
- *          <p>Conditional deletes are useful for deleting items only if specific conditions are met. If those conditions are met, DynamoDB performs the delete. Otherwise, the item is not deleted.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DeleteItemCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DeleteItemCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DeleteItemCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteItemCommandInput} for command's `input` shape.
- * @see {@link DeleteItemCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteItemCommand extends $Command<DeleteItemCommandInput, DeleteItemCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: DeleteItemCommandInput;
-    constructor(input: DeleteItemCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteItemCommandInput, DeleteItemCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DeleteTableCommand.d.ts

@@ -1,51 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DeleteTableInput, DeleteTableOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteTableCommandInput extends DeleteTableInput {
-}
-export interface DeleteTableCommandOutput extends DeleteTableOutput, __MetadataBearer {
-}
-/**
- * <p>The <code>DeleteTable</code> operation deletes a table and all of its items. After a
- *         <code>DeleteTable</code> request, the specified table is in the <code>DELETING</code> state until
- *       DynamoDB completes the deletion. If the table is in the <code>ACTIVE</code> state, you can delete
- *       it. If a table is in <code>CREATING</code> or <code>UPDATING</code> states, then DynamoDB returns
- *       a <code>ResourceInUseException</code>. If the specified table does not exist, DynamoDB returns a
- *         <code>ResourceNotFoundException</code>. If table is already in the <code>DELETING</code> state, no
- *       error is returned. </p>
- *          <note>
- *             <p>DynamoDB might continue to accept data read and write operations, such as <code>GetItem</code> and
- *           <code>PutItem</code>, on a table in the <code>DELETING</code> state until the table deletion is
- *         complete.</p>
- *          </note>
- *          <p>When you delete a table, any indexes on that table are also deleted.</p>
- *          <p>If you have DynamoDB Streams enabled on the table, then the corresponding stream on that table goes
- *       into the <code>DISABLED</code> state, and the stream is automatically deleted after 24 hours.</p>
- *
- *          <p>Use the <code>DescribeTable</code> action to check the status of the table. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DeleteTableCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DeleteTableCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DeleteTableCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTableCommandInput} for command's `input` shape.
- * @see {@link DeleteTableCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteTableCommand extends $Command<DeleteTableCommandInput, DeleteTableCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: DeleteTableCommandInput;
-    constructor(input: DeleteTableCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTableCommandInput, DeleteTableCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeBackupCommand.d.ts

@@ -1,36 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeBackupInput, DescribeBackupOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeBackupCommandInput extends DescribeBackupInput {
-}
-export interface DescribeBackupCommandOutput extends DescribeBackupOutput, __MetadataBearer {
-}
-/**
- * <p>Describes an existing backup of a table.</p>
- *          <p>You can call <code>DescribeBackup</code> at a maximum rate of 10 times per second.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DescribeBackupCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeBackupCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeBackupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeBackupCommandInput} for command's `input` shape.
- * @see {@link DescribeBackupCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeBackupCommand extends $Command<DescribeBackupCommandInput, DescribeBackupCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: DescribeBackupCommandInput;
-    constructor(input: DescribeBackupCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeBackupCommandInput, DescribeBackupCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeContinuousBackupsCommand.d.ts

@@ -1,45 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeContinuousBackupsInput, DescribeContinuousBackupsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeContinuousBackupsCommandInput extends DescribeContinuousBackupsInput {
-}
-export interface DescribeContinuousBackupsCommandOutput extends DescribeContinuousBackupsOutput, __MetadataBearer {
-}
-/**
- * <p>Checks the status of continuous backups and point in time recovery on the specified table.
- *       Continuous backups are <code>ENABLED</code> on all tables at table creation.
- *       If point in time recovery is enabled, <code>PointInTimeRecoveryStatus</code> will be set to ENABLED.</p>
- *          <p> After continuous backups and point in time recovery are enabled, you can restore to any
- *             point in time within <code>EarliestRestorableDateTime</code> and
- *                 <code>LatestRestorableDateTime</code>. </p>
- *          <p>
- *             <code>LatestRestorableDateTime</code> is typically 5 minutes before the current time. You can restore your table to any point
- *        in time during the last 35 days.
- *      </p>
- *          <p>You can call <code>DescribeContinuousBackups</code> at a maximum rate of 10 times per second.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DescribeContinuousBackupsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeContinuousBackupsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeContinuousBackupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeContinuousBackupsCommandInput} for command's `input` shape.
- * @see {@link DescribeContinuousBackupsCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeContinuousBackupsCommand extends $Command<DescribeContinuousBackupsCommandInput, DescribeContinuousBackupsCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: DescribeContinuousBackupsCommandInput;
-    constructor(input: DescribeContinuousBackupsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeContinuousBackupsCommandInput, DescribeContinuousBackupsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeContributorInsightsCommand.d.ts

@@ -1,35 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeContributorInsightsInput, DescribeContributorInsightsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeContributorInsightsCommandInput extends DescribeContributorInsightsInput {
-}
-export interface DescribeContributorInsightsCommandOutput extends DescribeContributorInsightsOutput, __MetadataBearer {
-}
-/**
- * <p>Returns information about contributor insights, for a given table or global secondary index.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DescribeContributorInsightsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeContributorInsightsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeContributorInsightsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeContributorInsightsCommandInput} for command's `input` shape.
- * @see {@link DescribeContributorInsightsCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeContributorInsightsCommand extends $Command<DescribeContributorInsightsCommandInput, DescribeContributorInsightsCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: DescribeContributorInsightsCommandInput;
-    constructor(input: DescribeContributorInsightsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeContributorInsightsCommandInput, DescribeContributorInsightsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeEndpointsCommand.d.ts

@@ -1,35 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeEndpointsRequest, DescribeEndpointsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeEndpointsCommandInput extends DescribeEndpointsRequest {
-}
-export interface DescribeEndpointsCommandOutput extends DescribeEndpointsResponse, __MetadataBearer {
-}
-/**
- * <p>Returns the regional endpoint information.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DescribeEndpointsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeEndpointsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeEndpointsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEndpointsCommandInput} for command's `input` shape.
- * @see {@link DescribeEndpointsCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeEndpointsCommand extends $Command<DescribeEndpointsCommandInput, DescribeEndpointsCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: DescribeEndpointsCommandInput;
-    constructor(input: DescribeEndpointsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEndpointsCommandInput, DescribeEndpointsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeExportCommand.d.ts

@@ -1,35 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeExportInput, DescribeExportOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeExportCommandInput extends DescribeExportInput {
-}
-export interface DescribeExportCommandOutput extends DescribeExportOutput, __MetadataBearer {
-}
-/**
- * <p>Describes an existing table export.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DescribeExportCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeExportCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeExportCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeExportCommandInput} for command's `input` shape.
- * @see {@link DescribeExportCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeExportCommand extends $Command<DescribeExportCommandInput, DescribeExportCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: DescribeExportCommandInput;
-    constructor(input: DescribeExportCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeExportCommandInput, DescribeExportCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeGlobalTableCommand.d.ts

@@ -1,39 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeGlobalTableInput, DescribeGlobalTableOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeGlobalTableCommandInput extends DescribeGlobalTableInput {
-}
-export interface DescribeGlobalTableCommandOutput extends DescribeGlobalTableOutput, __MetadataBearer {
-}
-/**
- * <p>Returns information about the specified global table.</p>
- *           <note>
- *             <p>This operation only applies to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 2017.11.29</a> of global tables.
- *                    If you are using global tables <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 2019.11.21</a> you can use <a href="https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html">DescribeTable</a> instead.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DescribeGlobalTableCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeGlobalTableCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeGlobalTableCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeGlobalTableCommandInput} for command's `input` shape.
- * @see {@link DescribeGlobalTableCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeGlobalTableCommand extends $Command<DescribeGlobalTableCommandInput, DescribeGlobalTableCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: DescribeGlobalTableCommandInput;
-    constructor(input: DescribeGlobalTableCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeGlobalTableCommandInput, DescribeGlobalTableCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeGlobalTableSettingsCommand.d.ts

@@ -1,38 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeGlobalTableSettingsInput, DescribeGlobalTableSettingsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeGlobalTableSettingsCommandInput extends DescribeGlobalTableSettingsInput {
-}
-export interface DescribeGlobalTableSettingsCommandOutput extends DescribeGlobalTableSettingsOutput, __MetadataBearer {
-}
-/**
- * <p>Describes Region-specific settings for a global table.</p>
- *           <note>
- *             <p>This operation only applies to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 2017.11.29</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, DescribeGlobalTableSettingsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeGlobalTableSettingsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeGlobalTableSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeGlobalTableSettingsCommandInput} for command's `input` shape.
- * @see {@link DescribeGlobalTableSettingsCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeGlobalTableSettingsCommand extends $Command<DescribeGlobalTableSettingsCommandInput, DescribeGlobalTableSettingsCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: DescribeGlobalTableSettingsCommandInput;
-    constructor(input: DescribeGlobalTableSettingsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeGlobalTableSettingsCommandInput, DescribeGlobalTableSettingsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeKinesisStreamingDestinationCommand.d.ts

@@ -1,35 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeKinesisStreamingDestinationInput, DescribeKinesisStreamingDestinationOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeKinesisStreamingDestinationCommandInput extends DescribeKinesisStreamingDestinationInput {
-}
-export interface DescribeKinesisStreamingDestinationCommandOutput extends DescribeKinesisStreamingDestinationOutput, __MetadataBearer {
-}
-/**
- * <p>Returns information about the status of Kinesis streaming.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DynamoDBClient, DescribeKinesisStreamingDestinationCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
- * // const { DynamoDBClient, DescribeKinesisStreamingDestinationCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
- * const client = new DynamoDBClient(config);
- * const command = new DescribeKinesisStreamingDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeKinesisStreamingDestinationCommandInput} for command's `input` shape.
- * @see {@link DescribeKinesisStreamingDestinationCommandOutput} for command's `response` shape.
- * @see {@link DynamoDBClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeKinesisStreamingDestinationCommand extends $Command<DescribeKinesisStreamingDestinationCommandInput, DescribeKinesisStreamingDestinationCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: DescribeKinesisStreamingDestinationCommandInput;
-    constructor(input: DescribeKinesisStreamingDestinationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeKinesisStreamingDestinationCommandInput, DescribeKinesisStreamingDestinationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeLimitsCommand.d.ts

@@ -1,98 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeLimitsInput, DescribeLimitsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } 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 declare class DescribeLimitsCommand extends $Command<DescribeLimitsCommandInput, DescribeLimitsCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: DescribeLimitsCommandInput;
-    constructor(input: DescribeLimitsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLimitsCommandInput, DescribeLimitsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/DescribeTableCommand.d.ts

@@ -1,41 +0,0 @@
-import { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
-import { DescribeTableInput, DescribeTableOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } 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 declare class DescribeTableCommand extends $Command<DescribeTableCommandInput, DescribeTableCommandOutput, DynamoDBClientResolvedConfig> {
-    readonly input: DescribeTableCommandInput;
-    constructor(input: DescribeTableCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTableCommandInput, DescribeTableCommandOutput>;
-    private serialize;
-    private deserialize;
-}