@depup/aws-sdk__client-dynamodb 3.1005.0-depup.0

package/dist-types/commands/UpdateTableReplicaAutoScalingCommand.d.ts

@@ -0,0 +1,246 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import type { UpdateTableReplicaAutoScalingInput, UpdateTableReplicaAutoScalingOutput } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link UpdateTableReplicaAutoScalingCommand}.
+ */
+export interface UpdateTableReplicaAutoScalingCommandInput extends UpdateTableReplicaAutoScalingInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link UpdateTableReplicaAutoScalingCommand}.
+ */
+export interface UpdateTableReplicaAutoScalingCommandOutput extends UpdateTableReplicaAutoScalingOutput, __MetadataBearer {
+}
+declare const UpdateTableReplicaAutoScalingCommand_base: {
+    new (input: UpdateTableReplicaAutoScalingCommandInput): import("@smithy/smithy-client").CommandImpl<UpdateTableReplicaAutoScalingCommandInput, UpdateTableReplicaAutoScalingCommandOutput, DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: UpdateTableReplicaAutoScalingCommandInput): import("@smithy/smithy-client").CommandImpl<UpdateTableReplicaAutoScalingCommandInput, UpdateTableReplicaAutoScalingCommandOutput, DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Updates auto scaling settings on your global tables at once.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, UpdateTableReplicaAutoScalingCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, UpdateTableReplicaAutoScalingCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * // import type { DynamoDBClientConfig } from "@aws-sdk/client-dynamodb";
+ * const config = {}; // type is DynamoDBClientConfig
+ * const client = new DynamoDBClient(config);
+ * const input = { // UpdateTableReplicaAutoScalingInput
+ *   GlobalSecondaryIndexUpdates: [ // GlobalSecondaryIndexAutoScalingUpdateList
+ *     { // GlobalSecondaryIndexAutoScalingUpdate
+ *       IndexName: "STRING_VALUE",
+ *       ProvisionedWriteCapacityAutoScalingUpdate: { // AutoScalingSettingsUpdate
+ *         MinimumUnits: Number("long"),
+ *         MaximumUnits: Number("long"),
+ *         AutoScalingDisabled: true || false,
+ *         AutoScalingRoleArn: "STRING_VALUE",
+ *         ScalingPolicyUpdate: { // AutoScalingPolicyUpdate
+ *           PolicyName: "STRING_VALUE",
+ *           TargetTrackingScalingPolicyConfiguration: { // AutoScalingTargetTrackingScalingPolicyConfigurationUpdate
+ *             DisableScaleIn: true || false,
+ *             ScaleInCooldown: Number("int"),
+ *             ScaleOutCooldown: Number("int"),
+ *             TargetValue: Number("double"), // required
+ *           },
+ *         },
+ *       },
+ *     },
+ *   ],
+ *   TableName: "STRING_VALUE", // required
+ *   ProvisionedWriteCapacityAutoScalingUpdate: {
+ *     MinimumUnits: Number("long"),
+ *     MaximumUnits: Number("long"),
+ *     AutoScalingDisabled: true || false,
+ *     AutoScalingRoleArn: "STRING_VALUE",
+ *     ScalingPolicyUpdate: {
+ *       PolicyName: "STRING_VALUE",
+ *       TargetTrackingScalingPolicyConfiguration: {
+ *         DisableScaleIn: true || false,
+ *         ScaleInCooldown: Number("int"),
+ *         ScaleOutCooldown: Number("int"),
+ *         TargetValue: Number("double"), // required
+ *       },
+ *     },
+ *   },
+ *   ReplicaUpdates: [ // ReplicaAutoScalingUpdateList
+ *     { // ReplicaAutoScalingUpdate
+ *       RegionName: "STRING_VALUE", // required
+ *       ReplicaGlobalSecondaryIndexUpdates: [ // ReplicaGlobalSecondaryIndexAutoScalingUpdateList
+ *         { // ReplicaGlobalSecondaryIndexAutoScalingUpdate
+ *           IndexName: "STRING_VALUE",
+ *           ProvisionedReadCapacityAutoScalingUpdate: "<AutoScalingSettingsUpdate>",
+ *         },
+ *       ],
+ *       ReplicaProvisionedReadCapacityAutoScalingUpdate: "<AutoScalingSettingsUpdate>",
+ *     },
+ *   ],
+ * };
+ * const command = new UpdateTableReplicaAutoScalingCommand(input);
+ * const response = await client.send(command);
+ * // { // UpdateTableReplicaAutoScalingOutput
+ * //   TableAutoScalingDescription: { // TableAutoScalingDescription
+ * //     TableName: "STRING_VALUE",
+ * //     TableStatus: "CREATING" || "UPDATING" || "DELETING" || "ACTIVE" || "INACCESSIBLE_ENCRYPTION_CREDENTIALS" || "ARCHIVING" || "ARCHIVED" || "REPLICATION_NOT_AUTHORIZED",
+ * //     Replicas: [ // ReplicaAutoScalingDescriptionList
+ * //       { // ReplicaAutoScalingDescription
+ * //         RegionName: "STRING_VALUE",
+ * //         GlobalSecondaryIndexes: [ // ReplicaGlobalSecondaryIndexAutoScalingDescriptionList
+ * //           { // ReplicaGlobalSecondaryIndexAutoScalingDescription
+ * //             IndexName: "STRING_VALUE",
+ * //             IndexStatus: "CREATING" || "UPDATING" || "DELETING" || "ACTIVE",
+ * //             ProvisionedReadCapacityAutoScalingSettings: { // AutoScalingSettingsDescription
+ * //               MinimumUnits: Number("long"),
+ * //               MaximumUnits: Number("long"),
+ * //               AutoScalingDisabled: true || false,
+ * //               AutoScalingRoleArn: "STRING_VALUE",
+ * //               ScalingPolicies: [ // AutoScalingPolicyDescriptionList
+ * //                 { // AutoScalingPolicyDescription
+ * //                   PolicyName: "STRING_VALUE",
+ * //                   TargetTrackingScalingPolicyConfiguration: { // AutoScalingTargetTrackingScalingPolicyConfigurationDescription
+ * //                     DisableScaleIn: true || false,
+ * //                     ScaleInCooldown: Number("int"),
+ * //                     ScaleOutCooldown: Number("int"),
+ * //                     TargetValue: Number("double"), // required
+ * //                   },
+ * //                 },
+ * //               ],
+ * //             },
+ * //             ProvisionedWriteCapacityAutoScalingSettings: {
+ * //               MinimumUnits: Number("long"),
+ * //               MaximumUnits: Number("long"),
+ * //               AutoScalingDisabled: true || false,
+ * //               AutoScalingRoleArn: "STRING_VALUE",
+ * //               ScalingPolicies: [
+ * //                 {
+ * //                   PolicyName: "STRING_VALUE",
+ * //                   TargetTrackingScalingPolicyConfiguration: {
+ * //                     DisableScaleIn: true || false,
+ * //                     ScaleInCooldown: Number("int"),
+ * //                     ScaleOutCooldown: Number("int"),
+ * //                     TargetValue: Number("double"), // required
+ * //                   },
+ * //                 },
+ * //               ],
+ * //             },
+ * //           },
+ * //         ],
+ * //         ReplicaProvisionedReadCapacityAutoScalingSettings: {
+ * //           MinimumUnits: Number("long"),
+ * //           MaximumUnits: Number("long"),
+ * //           AutoScalingDisabled: true || false,
+ * //           AutoScalingRoleArn: "STRING_VALUE",
+ * //           ScalingPolicies: [
+ * //             {
+ * //               PolicyName: "STRING_VALUE",
+ * //               TargetTrackingScalingPolicyConfiguration: {
+ * //                 DisableScaleIn: true || false,
+ * //                 ScaleInCooldown: Number("int"),
+ * //                 ScaleOutCooldown: Number("int"),
+ * //                 TargetValue: Number("double"), // required
+ * //               },
+ * //             },
+ * //           ],
+ * //         },
+ * //         ReplicaProvisionedWriteCapacityAutoScalingSettings: {
+ * //           MinimumUnits: Number("long"),
+ * //           MaximumUnits: Number("long"),
+ * //           AutoScalingDisabled: true || false,
+ * //           AutoScalingRoleArn: "STRING_VALUE",
+ * //           ScalingPolicies: [
+ * //             {
+ * //               PolicyName: "STRING_VALUE",
+ * //               TargetTrackingScalingPolicyConfiguration: {
+ * //                 DisableScaleIn: true || false,
+ * //                 ScaleInCooldown: Number("int"),
+ * //                 ScaleOutCooldown: Number("int"),
+ * //                 TargetValue: Number("double"), // required
+ * //               },
+ * //             },
+ * //           ],
+ * //         },
+ * //         ReplicaStatus: "CREATING" || "CREATION_FAILED" || "UPDATING" || "DELETING" || "ACTIVE" || "REGION_DISABLED" || "INACCESSIBLE_ENCRYPTION_CREDENTIALS" || "ARCHIVING" || "ARCHIVED" || "REPLICATION_NOT_AUTHORIZED",
+ * //       },
+ * //     ],
+ * //   },
+ * // };
+ *
+ * ```
+ *
+ * @param UpdateTableReplicaAutoScalingCommandInput - {@link UpdateTableReplicaAutoScalingCommandInput}
+ * @returns {@link UpdateTableReplicaAutoScalingCommandOutput}
+ * @see {@link UpdateTableReplicaAutoScalingCommandInput} for command's `input` shape.
+ * @see {@link UpdateTableReplicaAutoScalingCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for DynamoDBClient's `config` shape.
+ *
+ * @throws {@link InternalServerError} (server fault)
+ *  <p>An error occurred on the server side.</p>
+ *
+ * @throws {@link LimitExceededException} (client fault)
+ *  <p>There is no limit to the number of daily on-demand backups that can be taken. </p>
+ *          <p>For most purposes, up to 500 simultaneous table operations are allowed per account.
+ *             These operations include <code>CreateTable</code>, <code>UpdateTable</code>,
+ *                 <code>DeleteTable</code>,<code>UpdateTimeToLive</code>,
+ *                 <code>RestoreTableFromBackup</code>, and <code>RestoreTableToPointInTime</code>. </p>
+ *          <p>When you are creating a table with one or more secondary indexes, you can have up
+ *             to 250 such requests running at a time. However, if the table or index specifications
+ *             are complex, then DynamoDB might temporarily reduce the number of concurrent
+ *             operations.</p>
+ *          <p>When importing into DynamoDB, up to 50 simultaneous import table operations are
+ *             allowed per account.</p>
+ *          <p>There is a soft account quota of 2,500 tables.</p>
+ *          <p>GetRecords was called with a value of more than 1000 for the limit request
+ *             parameter.</p>
+ *          <p>More than 2 processes are reading from the same streams shard at the same time.
+ *             Exceeding this limit may result in request throttling.</p>
+ *
+ * @throws {@link ResourceInUseException} (client fault)
+ *  <p>The operation conflicts with the resource's availability. For example:</p>
+ *          <ul>
+ *             <li>
+ *                <p>You attempted to recreate an existing table.</p>
+ *             </li>
+ *             <li>
+ *                <p>You tried to delete a table currently in the <code>CREATING</code>
+ *                     state.</p>
+ *             </li>
+ *             <li>
+ *                <p>You tried to update a resource that was already being updated.</p>
+ *             </li>
+ *          </ul>
+ *          <p>When appropriate, wait for the ongoing update to complete and attempt the request
+ *             again.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>The operation tried to access a nonexistent table or index. The resource might not
+ *             be specified correctly, or its status might not be <code>ACTIVE</code>.</p>
+ *
+ * @throws {@link DynamoDBServiceException}
+ * <p>Base exception class for all service exceptions from DynamoDB service.</p>
+ *
+ *
+ * @public
+ */
+export declare class UpdateTableReplicaAutoScalingCommand extends UpdateTableReplicaAutoScalingCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: UpdateTableReplicaAutoScalingInput;
+            output: UpdateTableReplicaAutoScalingOutput;
+        };
+        sdk: {
+            input: UpdateTableReplicaAutoScalingCommandInput;
+            output: UpdateTableReplicaAutoScalingCommandOutput;
+        };
+    };
+}

package/dist-types/commands/UpdateTimeToLiveCommand.d.ts

@@ -0,0 +1,149 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBClient";
+import type { UpdateTimeToLiveInput, UpdateTimeToLiveOutput } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link UpdateTimeToLiveCommand}.
+ */
+export interface UpdateTimeToLiveCommandInput extends UpdateTimeToLiveInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link UpdateTimeToLiveCommand}.
+ */
+export interface UpdateTimeToLiveCommandOutput extends UpdateTimeToLiveOutput, __MetadataBearer {
+}
+declare const UpdateTimeToLiveCommand_base: {
+    new (input: UpdateTimeToLiveCommandInput): import("@smithy/smithy-client").CommandImpl<UpdateTimeToLiveCommandInput, UpdateTimeToLiveCommandOutput, DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: UpdateTimeToLiveCommandInput): import("@smithy/smithy-client").CommandImpl<UpdateTimeToLiveCommandInput, UpdateTimeToLiveCommandOutput, DynamoDBClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>The <code>UpdateTimeToLive</code> method enables or disables Time to Live (TTL) for
+ *             the specified table. A successful <code>UpdateTimeToLive</code> call returns the current
+ *                 <code>TimeToLiveSpecification</code>. It can take up to one hour for the change to
+ *             fully process. Any additional <code>UpdateTimeToLive</code> calls for the same table
+ *             during this one hour duration result in a <code>ValidationException</code>. </p>
+ *          <p>TTL compares the current time in epoch time format to the time stored in the TTL
+ *             attribute of an item. If the epoch time value stored in the attribute is less than the
+ *             current time, the item is marked as expired and subsequently deleted.</p>
+ *          <note>
+ *             <p> The epoch time format is the number of seconds elapsed since 12:00:00 AM January
+ *                 1, 1970 UTC. </p>
+ *          </note>
+ *          <p>DynamoDB deletes expired items on a best-effort basis to ensure availability of
+ *             throughput for other data operations. </p>
+ *          <important>
+ *             <p>DynamoDB typically deletes expired items within two days of expiration. The exact
+ *                 duration within which an item gets deleted after expiration is specific to the
+ *                 nature of the workload. Items that have expired and not been deleted will still show
+ *                 up in reads, queries, and scans.</p>
+ *          </important>
+ *          <p>As items are deleted, they are removed from any local secondary index and global
+ *             secondary index immediately in the same eventually consistent way as a standard delete
+ *             operation.</p>
+ *          <p>For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html">Time To Live</a> in the
+ *             Amazon DynamoDB Developer Guide. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { DynamoDBClient, UpdateTimeToLiveCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
+ * // const { DynamoDBClient, UpdateTimeToLiveCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
+ * // import type { DynamoDBClientConfig } from "@aws-sdk/client-dynamodb";
+ * const config = {}; // type is DynamoDBClientConfig
+ * const client = new DynamoDBClient(config);
+ * const input = { // UpdateTimeToLiveInput
+ *   TableName: "STRING_VALUE", // required
+ *   TimeToLiveSpecification: { // TimeToLiveSpecification
+ *     Enabled: true || false, // required
+ *     AttributeName: "STRING_VALUE", // required
+ *   },
+ * };
+ * const command = new UpdateTimeToLiveCommand(input);
+ * const response = await client.send(command);
+ * // { // UpdateTimeToLiveOutput
+ * //   TimeToLiveSpecification: { // TimeToLiveSpecification
+ * //     Enabled: true || false, // required
+ * //     AttributeName: "STRING_VALUE", // required
+ * //   },
+ * // };
+ *
+ * ```
+ *
+ * @param UpdateTimeToLiveCommandInput - {@link UpdateTimeToLiveCommandInput}
+ * @returns {@link UpdateTimeToLiveCommandOutput}
+ * @see {@link UpdateTimeToLiveCommandInput} for command's `input` shape.
+ * @see {@link UpdateTimeToLiveCommandOutput} for command's `response` shape.
+ * @see {@link DynamoDBClientResolvedConfig | config} for DynamoDBClient's `config` shape.
+ *
+ * @throws {@link InternalServerError} (server fault)
+ *  <p>An error occurred on the server side.</p>
+ *
+ * @throws {@link InvalidEndpointException} (client fault)
+ *
+ * @throws {@link LimitExceededException} (client fault)
+ *  <p>There is no limit to the number of daily on-demand backups that can be taken. </p>
+ *          <p>For most purposes, up to 500 simultaneous table operations are allowed per account.
+ *             These operations include <code>CreateTable</code>, <code>UpdateTable</code>,
+ *                 <code>DeleteTable</code>,<code>UpdateTimeToLive</code>,
+ *                 <code>RestoreTableFromBackup</code>, and <code>RestoreTableToPointInTime</code>. </p>
+ *          <p>When you are creating a table with one or more secondary indexes, you can have up
+ *             to 250 such requests running at a time. However, if the table or index specifications
+ *             are complex, then DynamoDB might temporarily reduce the number of concurrent
+ *             operations.</p>
+ *          <p>When importing into DynamoDB, up to 50 simultaneous import table operations are
+ *             allowed per account.</p>
+ *          <p>There is a soft account quota of 2,500 tables.</p>
+ *          <p>GetRecords was called with a value of more than 1000 for the limit request
+ *             parameter.</p>
+ *          <p>More than 2 processes are reading from the same streams shard at the same time.
+ *             Exceeding this limit may result in request throttling.</p>
+ *
+ * @throws {@link ResourceInUseException} (client fault)
+ *  <p>The operation conflicts with the resource's availability. For example:</p>
+ *          <ul>
+ *             <li>
+ *                <p>You attempted to recreate an existing table.</p>
+ *             </li>
+ *             <li>
+ *                <p>You tried to delete a table currently in the <code>CREATING</code>
+ *                     state.</p>
+ *             </li>
+ *             <li>
+ *                <p>You tried to update a resource that was already being updated.</p>
+ *             </li>
+ *          </ul>
+ *          <p>When appropriate, wait for the ongoing update to complete and attempt the request
+ *             again.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>The operation tried to access a nonexistent table or index. The resource might not
+ *             be specified correctly, or its status might not be <code>ACTIVE</code>.</p>
+ *
+ * @throws {@link DynamoDBServiceException}
+ * <p>Base exception class for all service exceptions from DynamoDB service.</p>
+ *
+ *
+ * @public
+ */
+export declare class UpdateTimeToLiveCommand extends UpdateTimeToLiveCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: UpdateTimeToLiveInput;
+            output: UpdateTimeToLiveOutput;
+        };
+        sdk: {
+            input: UpdateTimeToLiveCommandInput;
+            output: UpdateTimeToLiveCommandOutput;
+        };
+    };
+}

package/dist-types/commands/index.d.ts

@@ -0,0 +1,57 @@
+export * from "./BatchExecuteStatementCommand";
+export * from "./BatchGetItemCommand";
+export * from "./BatchWriteItemCommand";
+export * from "./CreateBackupCommand";
+export * from "./CreateGlobalTableCommand";
+export * from "./CreateTableCommand";
+export * from "./DeleteBackupCommand";
+export * from "./DeleteItemCommand";
+export * from "./DeleteResourcePolicyCommand";
+export * from "./DeleteTableCommand";
+export * from "./DescribeBackupCommand";
+export * from "./DescribeContinuousBackupsCommand";
+export * from "./DescribeContributorInsightsCommand";
+export * from "./DescribeEndpointsCommand";
+export * from "./DescribeExportCommand";
+export * from "./DescribeGlobalTableCommand";
+export * from "./DescribeGlobalTableSettingsCommand";
+export * from "./DescribeImportCommand";
+export * from "./DescribeKinesisStreamingDestinationCommand";
+export * from "./DescribeLimitsCommand";
+export * from "./DescribeTableCommand";
+export * from "./DescribeTableReplicaAutoScalingCommand";
+export * from "./DescribeTimeToLiveCommand";
+export * from "./DisableKinesisStreamingDestinationCommand";
+export * from "./EnableKinesisStreamingDestinationCommand";
+export * from "./ExecuteStatementCommand";
+export * from "./ExecuteTransactionCommand";
+export * from "./ExportTableToPointInTimeCommand";
+export * from "./GetItemCommand";
+export * from "./GetResourcePolicyCommand";
+export * from "./ImportTableCommand";
+export * from "./ListBackupsCommand";
+export * from "./ListContributorInsightsCommand";
+export * from "./ListExportsCommand";
+export * from "./ListGlobalTablesCommand";
+export * from "./ListImportsCommand";
+export * from "./ListTablesCommand";
+export * from "./ListTagsOfResourceCommand";
+export * from "./PutItemCommand";
+export * from "./PutResourcePolicyCommand";
+export * from "./QueryCommand";
+export * from "./RestoreTableFromBackupCommand";
+export * from "./RestoreTableToPointInTimeCommand";
+export * from "./ScanCommand";
+export * from "./TagResourceCommand";
+export * from "./TransactGetItemsCommand";
+export * from "./TransactWriteItemsCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateContinuousBackupsCommand";
+export * from "./UpdateContributorInsightsCommand";
+export * from "./UpdateGlobalTableCommand";
+export * from "./UpdateGlobalTableSettingsCommand";
+export * from "./UpdateItemCommand";
+export * from "./UpdateKinesisStreamingDestinationCommand";
+export * from "./UpdateTableCommand";
+export * from "./UpdateTableReplicaAutoScalingCommand";
+export * from "./UpdateTimeToLiveCommand";

package/dist-types/endpoint/EndpointParameters.d.ts

@@ -0,0 +1,64 @@
+import type { Endpoint, EndpointParameters as __EndpointParameters, EndpointV2, Provider } from "@smithy/types";
+/**
+ * @public
+ */
+export interface ClientInputEndpointParameters {
+    region?: string | undefined | Provider<string | undefined>;
+    useDualstackEndpoint?: boolean | undefined | Provider<boolean | undefined>;
+    useFipsEndpoint?: boolean | undefined | Provider<boolean | undefined>;
+    endpoint?: string | Provider<string> | Endpoint | Provider<Endpoint> | EndpointV2 | Provider<EndpointV2>;
+    accountId?: string | undefined | Provider<string | undefined>;
+    accountIdEndpointMode?: string | undefined | Provider<string | undefined>;
+}
+/**
+ * @public
+ */
+export type ClientResolvedEndpointParameters = Omit<ClientInputEndpointParameters, "endpoint"> & {
+    defaultSigningName: string;
+};
+/**
+ * @internal
+ */
+export declare const resolveClientEndpointParameters: <T>(options: T & ClientInputEndpointParameters) => T & ClientResolvedEndpointParameters;
+/**
+ * @internal
+ */
+export declare const commonParams: {
+    readonly UseFIPS: {
+        readonly type: "builtInParams";
+        readonly name: "useFipsEndpoint";
+    };
+    readonly AccountId: {
+        readonly type: "builtInParams";
+        readonly name: "accountId";
+    };
+    readonly Endpoint: {
+        readonly type: "builtInParams";
+        readonly name: "endpoint";
+    };
+    readonly Region: {
+        readonly type: "builtInParams";
+        readonly name: "region";
+    };
+    readonly UseDualStack: {
+        readonly type: "builtInParams";
+        readonly name: "useDualstackEndpoint";
+    };
+    readonly AccountIdEndpointMode: {
+        readonly type: "builtInParams";
+        readonly name: "accountIdEndpointMode";
+    };
+};
+/**
+ * @internal
+ */
+export interface EndpointParameters extends __EndpointParameters {
+    Region?: string | undefined;
+    UseDualStack?: boolean | undefined;
+    UseFIPS?: boolean | undefined;
+    Endpoint?: string | undefined;
+    AccountId?: string | undefined;
+    AccountIdEndpointMode?: string | undefined;
+    ResourceArn?: string | undefined;
+    ResourceArnList?: string[] | undefined;
+}

package/dist-types/endpoint/endpointResolver.d.ts

@@ -0,0 +1,8 @@
+import type { EndpointV2, Logger } from "@smithy/types";
+import type { EndpointParameters } from "./EndpointParameters";
+/**
+ * @internal
+ */
+export declare const defaultEndpointResolver: (endpointParams: EndpointParameters, context?: {
+    logger?: Logger;
+}) => EndpointV2;

package/dist-types/endpoint/ruleset.d.ts

@@ -0,0 +1,2 @@
+import { RuleSetObject } from "@smithy/types";
+export declare const ruleSet: RuleSetObject;

package/dist-types/extensionConfiguration.d.ts

@@ -0,0 +1,9 @@
+import type { AwsRegionExtensionConfiguration } from "@aws-sdk/types";
+import type { HttpHandlerExtensionConfiguration } from "@smithy/protocol-http";
+import type { DefaultExtensionConfiguration } from "@smithy/types";
+import type { HttpAuthExtensionConfiguration } from "./auth/httpAuthExtensionConfiguration";
+/**
+ * @internal
+ */
+export interface DynamoDBExtensionConfiguration extends HttpHandlerExtensionConfiguration, DefaultExtensionConfiguration, AwsRegionExtensionConfiguration, HttpAuthExtensionConfiguration {
+}

package/dist-types/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * <fullname>Amazon DynamoDB</fullname>
+ *          <p>Amazon DynamoDB is a fully managed NoSQL database service that provides fast
+ *             and predictable performance with seamless scalability. DynamoDB lets you
+ *             offload the administrative burdens of operating and scaling a distributed database, so
+ *             that you don't have to worry about hardware provisioning, setup and configuration,
+ *             replication, software patching, or cluster scaling.</p>
+ *          <p>With DynamoDB, you can create database tables that can store and retrieve
+ *             any amount of data, and serve any level of request traffic. You can scale up or scale
+ *             down your tables' throughput capacity without downtime or performance degradation, and
+ *             use the Amazon Web Services Management Console to monitor resource utilization and performance
+ *             metrics.</p>
+ *          <p>DynamoDB automatically spreads the data and traffic for your tables over
+ *             a sufficient number of servers to handle your throughput and storage requirements, while
+ *             maintaining consistent and fast performance. All of your data is stored on solid state
+ *             disks (SSDs) and automatically replicated across multiple Availability Zones in an
+ *                 Amazon Web Services Region, providing built-in high availability and data
+ *             durability.</p>
+ *
+ * @packageDocumentation
+ */
+export * from "./DynamoDBClient";
+export * from "./DynamoDB";
+export { ClientInputEndpointParameters } from "./endpoint/EndpointParameters";
+export type { RuntimeExtension } from "./runtimeExtensions";
+export type { DynamoDBExtensionConfiguration } from "./extensionConfiguration";
+export * from "./commands";
+export * from "./schemas/schemas_0";
+export * from "./pagination";
+export * from "./waiters";
+export * from "./models/enums";
+export * from "./models/errors";
+export * from "./models/models_0";
+export { DynamoDBServiceException } from "./models/DynamoDBServiceException";

package/dist-types/models/DynamoDBServiceException.d.ts

@@ -0,0 +1,14 @@
+import { type ServiceExceptionOptions as __ServiceExceptionOptions, ServiceException as __ServiceException } from "@smithy/smithy-client";
+export type { __ServiceExceptionOptions };
+export { __ServiceException };
+/**
+ * @public
+ *
+ * Base exception class for all service exceptions from DynamoDB service.
+ */
+export declare class DynamoDBServiceException extends __ServiceException {
+    /**
+     * @internal
+     */
+    constructor(options: __ServiceExceptionOptions);
+}