@aws-sdk/client-dynamodb 3.300.0 → 3.303.0

package/dist-es/models/models_0.js

@@ -1,71 +1,60 @@
 import { DynamoDBServiceException as __BaseException } from "./DynamoDBServiceException";
-export var AttributeAction;
-(function (AttributeAction) {
-    AttributeAction["ADD"] = "ADD";
-    AttributeAction["DELETE"] = "DELETE";
-    AttributeAction["PUT"] = "PUT";
-})(AttributeAction || (AttributeAction = {}));
-export var ScalarAttributeType;
-(function (ScalarAttributeType) {
-    ScalarAttributeType["B"] = "B";
-    ScalarAttributeType["N"] = "N";
-    ScalarAttributeType["S"] = "S";
-})(ScalarAttributeType || (ScalarAttributeType = {}));
-export var BackupStatus;
-(function (BackupStatus) {
-    BackupStatus["AVAILABLE"] = "AVAILABLE";
-    BackupStatus["CREATING"] = "CREATING";
-    BackupStatus["DELETED"] = "DELETED";
-})(BackupStatus || (BackupStatus = {}));
-export var BackupType;
-(function (BackupType) {
-    BackupType["AWS_BACKUP"] = "AWS_BACKUP";
-    BackupType["SYSTEM"] = "SYSTEM";
-    BackupType["USER"] = "USER";
-})(BackupType || (BackupType = {}));
-export var BillingMode;
-(function (BillingMode) {
-    BillingMode["PAY_PER_REQUEST"] = "PAY_PER_REQUEST";
-    BillingMode["PROVISIONED"] = "PROVISIONED";
-})(BillingMode || (BillingMode = {}));
-export var KeyType;
-(function (KeyType) {
-    KeyType["HASH"] = "HASH";
-    KeyType["RANGE"] = "RANGE";
-})(KeyType || (KeyType = {}));
-export var ProjectionType;
-(function (ProjectionType) {
-    ProjectionType["ALL"] = "ALL";
-    ProjectionType["INCLUDE"] = "INCLUDE";
-    ProjectionType["KEYS_ONLY"] = "KEYS_ONLY";
-})(ProjectionType || (ProjectionType = {}));
-export var SSEType;
-(function (SSEType) {
-    SSEType["AES256"] = "AES256";
-    SSEType["KMS"] = "KMS";
-})(SSEType || (SSEType = {}));
-export var SSEStatus;
-(function (SSEStatus) {
-    SSEStatus["DISABLED"] = "DISABLED";
-    SSEStatus["DISABLING"] = "DISABLING";
-    SSEStatus["ENABLED"] = "ENABLED";
-    SSEStatus["ENABLING"] = "ENABLING";
-    SSEStatus["UPDATING"] = "UPDATING";
-})(SSEStatus || (SSEStatus = {}));
-export var StreamViewType;
-(function (StreamViewType) {
-    StreamViewType["KEYS_ONLY"] = "KEYS_ONLY";
-    StreamViewType["NEW_AND_OLD_IMAGES"] = "NEW_AND_OLD_IMAGES";
-    StreamViewType["NEW_IMAGE"] = "NEW_IMAGE";
-    StreamViewType["OLD_IMAGE"] = "OLD_IMAGE";
-})(StreamViewType || (StreamViewType = {}));
-export var TimeToLiveStatus;
-(function (TimeToLiveStatus) {
-    TimeToLiveStatus["DISABLED"] = "DISABLED";
-    TimeToLiveStatus["DISABLING"] = "DISABLING";
-    TimeToLiveStatus["ENABLED"] = "ENABLED";
-    TimeToLiveStatus["ENABLING"] = "ENABLING";
-})(TimeToLiveStatus || (TimeToLiveStatus = {}));
+export const AttributeAction = {
+    ADD: "ADD",
+    DELETE: "DELETE",
+    PUT: "PUT",
+};
+export const ScalarAttributeType = {
+    B: "B",
+    N: "N",
+    S: "S",
+};
+export const BackupStatus = {
+    AVAILABLE: "AVAILABLE",
+    CREATING: "CREATING",
+    DELETED: "DELETED",
+};
+export const BackupType = {
+    AWS_BACKUP: "AWS_BACKUP",
+    SYSTEM: "SYSTEM",
+    USER: "USER",
+};
+export const BillingMode = {
+    PAY_PER_REQUEST: "PAY_PER_REQUEST",
+    PROVISIONED: "PROVISIONED",
+};
+export const KeyType = {
+    HASH: "HASH",
+    RANGE: "RANGE",
+};
+export const ProjectionType = {
+    ALL: "ALL",
+    INCLUDE: "INCLUDE",
+    KEYS_ONLY: "KEYS_ONLY",
+};
+export const SSEType = {
+    AES256: "AES256",
+    KMS: "KMS",
+};
+export const SSEStatus = {
+    DISABLED: "DISABLED",
+    DISABLING: "DISABLING",
+    ENABLED: "ENABLED",
+    ENABLING: "ENABLING",
+    UPDATING: "UPDATING",
+};
+export const StreamViewType = {
+    KEYS_ONLY: "KEYS_ONLY",
+    NEW_AND_OLD_IMAGES: "NEW_AND_OLD_IMAGES",
+    NEW_IMAGE: "NEW_IMAGE",
+    OLD_IMAGE: "OLD_IMAGE",
+};
+export const TimeToLiveStatus = {
+    DISABLED: "DISABLED",
+    DISABLING: "DISABLING",
+    ENABLED: "ENABLED",
+    ENABLING: "ENABLING",
+};
 export class BackupInUseException extends __BaseException {
     constructor(opts) {
         super({
@@ -90,33 +79,30 @@ export class BackupNotFoundException extends __BaseException {
         Object.setPrototypeOf(this, BackupNotFoundException.prototype);
     }
 }
-export var BackupTypeFilter;
-(function (BackupTypeFilter) {
-    BackupTypeFilter["ALL"] = "ALL";
-    BackupTypeFilter["AWS_BACKUP"] = "AWS_BACKUP";
-    BackupTypeFilter["SYSTEM"] = "SYSTEM";
-    BackupTypeFilter["USER"] = "USER";
-})(BackupTypeFilter || (BackupTypeFilter = {}));
-export var ReturnConsumedCapacity;
-(function (ReturnConsumedCapacity) {
-    ReturnConsumedCapacity["INDEXES"] = "INDEXES";
-    ReturnConsumedCapacity["NONE"] = "NONE";
-    ReturnConsumedCapacity["TOTAL"] = "TOTAL";
-})(ReturnConsumedCapacity || (ReturnConsumedCapacity = {}));
-export var BatchStatementErrorCodeEnum;
-(function (BatchStatementErrorCodeEnum) {
-    BatchStatementErrorCodeEnum["AccessDenied"] = "AccessDenied";
-    BatchStatementErrorCodeEnum["ConditionalCheckFailed"] = "ConditionalCheckFailed";
-    BatchStatementErrorCodeEnum["DuplicateItem"] = "DuplicateItem";
-    BatchStatementErrorCodeEnum["InternalServerError"] = "InternalServerError";
-    BatchStatementErrorCodeEnum["ItemCollectionSizeLimitExceeded"] = "ItemCollectionSizeLimitExceeded";
-    BatchStatementErrorCodeEnum["ProvisionedThroughputExceeded"] = "ProvisionedThroughputExceeded";
-    BatchStatementErrorCodeEnum["RequestLimitExceeded"] = "RequestLimitExceeded";
-    BatchStatementErrorCodeEnum["ResourceNotFound"] = "ResourceNotFound";
-    BatchStatementErrorCodeEnum["ThrottlingError"] = "ThrottlingError";
-    BatchStatementErrorCodeEnum["TransactionConflict"] = "TransactionConflict";
-    BatchStatementErrorCodeEnum["ValidationError"] = "ValidationError";
-})(BatchStatementErrorCodeEnum || (BatchStatementErrorCodeEnum = {}));
+export const BackupTypeFilter = {
+    ALL: "ALL",
+    AWS_BACKUP: "AWS_BACKUP",
+    SYSTEM: "SYSTEM",
+    USER: "USER",
+};
+export const ReturnConsumedCapacity = {
+    INDEXES: "INDEXES",
+    NONE: "NONE",
+    TOTAL: "TOTAL",
+};
+export const BatchStatementErrorCodeEnum = {
+    AccessDenied: "AccessDenied",
+    ConditionalCheckFailed: "ConditionalCheckFailed",
+    DuplicateItem: "DuplicateItem",
+    InternalServerError: "InternalServerError",
+    ItemCollectionSizeLimitExceeded: "ItemCollectionSizeLimitExceeded",
+    ProvisionedThroughputExceeded: "ProvisionedThroughputExceeded",
+    RequestLimitExceeded: "RequestLimitExceeded",
+    ResourceNotFound: "ResourceNotFound",
+    ThrottlingError: "ThrottlingError",
+    TransactionConflict: "TransactionConflict",
+    ValidationError: "ValidationError",
+};
 export class InternalServerError extends __BaseException {
     constructor(opts) {
         super({
@@ -178,11 +164,10 @@ export class ResourceNotFoundException extends __BaseException {
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
 }
-export var ReturnItemCollectionMetrics;
-(function (ReturnItemCollectionMetrics) {
-    ReturnItemCollectionMetrics["NONE"] = "NONE";
-    ReturnItemCollectionMetrics["SIZE"] = "SIZE";
-})(ReturnItemCollectionMetrics || (ReturnItemCollectionMetrics = {}));
+export const ReturnItemCollectionMetrics = {
+    NONE: "NONE",
+    SIZE: "SIZE",
+};
 export class ItemCollectionSizeLimitExceededException extends __BaseException {
     constructor(opts) {
         super({
@@ -195,22 +180,21 @@ export class ItemCollectionSizeLimitExceededException extends __BaseException {
         Object.setPrototypeOf(this, ItemCollectionSizeLimitExceededException.prototype);
     }
 }
-export var ComparisonOperator;
-(function (ComparisonOperator) {
-    ComparisonOperator["BEGINS_WITH"] = "BEGINS_WITH";
-    ComparisonOperator["BETWEEN"] = "BETWEEN";
-    ComparisonOperator["CONTAINS"] = "CONTAINS";
-    ComparisonOperator["EQ"] = "EQ";
-    ComparisonOperator["GE"] = "GE";
-    ComparisonOperator["GT"] = "GT";
-    ComparisonOperator["IN"] = "IN";
-    ComparisonOperator["LE"] = "LE";
-    ComparisonOperator["LT"] = "LT";
-    ComparisonOperator["NE"] = "NE";
-    ComparisonOperator["NOT_CONTAINS"] = "NOT_CONTAINS";
-    ComparisonOperator["NOT_NULL"] = "NOT_NULL";
-    ComparisonOperator["NULL"] = "NULL";
-})(ComparisonOperator || (ComparisonOperator = {}));
+export const ComparisonOperator = {
+    BEGINS_WITH: "BEGINS_WITH",
+    BETWEEN: "BETWEEN",
+    CONTAINS: "CONTAINS",
+    EQ: "EQ",
+    GE: "GE",
+    GT: "GT",
+    IN: "IN",
+    LE: "LE",
+    LT: "LT",
+    NE: "NE",
+    NOT_CONTAINS: "NOT_CONTAINS",
+    NOT_NULL: "NOT_NULL",
+    NULL: "NULL",
+};
 export class ConditionalCheckFailedException extends __BaseException {
     constructor(opts) {
         super({
@@ -223,26 +207,22 @@ export class ConditionalCheckFailedException extends __BaseException {
         Object.setPrototypeOf(this, ConditionalCheckFailedException.prototype);
     }
 }
-export var ConditionalOperator;
-(function (ConditionalOperator) {
-    ConditionalOperator["AND"] = "AND";
-    ConditionalOperator["OR"] = "OR";
-})(ConditionalOperator || (ConditionalOperator = {}));
-export var ReturnValuesOnConditionCheckFailure;
-(function (ReturnValuesOnConditionCheckFailure) {
-    ReturnValuesOnConditionCheckFailure["ALL_OLD"] = "ALL_OLD";
-    ReturnValuesOnConditionCheckFailure["NONE"] = "NONE";
-})(ReturnValuesOnConditionCheckFailure || (ReturnValuesOnConditionCheckFailure = {}));
-export var ContinuousBackupsStatus;
-(function (ContinuousBackupsStatus) {
-    ContinuousBackupsStatus["DISABLED"] = "DISABLED";
-    ContinuousBackupsStatus["ENABLED"] = "ENABLED";
-})(ContinuousBackupsStatus || (ContinuousBackupsStatus = {}));
-export var PointInTimeRecoveryStatus;
-(function (PointInTimeRecoveryStatus) {
-    PointInTimeRecoveryStatus["DISABLED"] = "DISABLED";
-    PointInTimeRecoveryStatus["ENABLED"] = "ENABLED";
-})(PointInTimeRecoveryStatus || (PointInTimeRecoveryStatus = {}));
+export const ConditionalOperator = {
+    AND: "AND",
+    OR: "OR",
+};
+export const ReturnValuesOnConditionCheckFailure = {
+    ALL_OLD: "ALL_OLD",
+    NONE: "NONE",
+};
+export const ContinuousBackupsStatus = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+export const PointInTimeRecoveryStatus = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
 export class ContinuousBackupsUnavailableException extends __BaseException {
     constructor(opts) {
         super({
@@ -255,19 +235,17 @@ export class ContinuousBackupsUnavailableException extends __BaseException {
         Object.setPrototypeOf(this, ContinuousBackupsUnavailableException.prototype);
     }
 }
-export var ContributorInsightsAction;
-(function (ContributorInsightsAction) {
-    ContributorInsightsAction["DISABLE"] = "DISABLE";
-    ContributorInsightsAction["ENABLE"] = "ENABLE";
-})(ContributorInsightsAction || (ContributorInsightsAction = {}));
-export var ContributorInsightsStatus;
-(function (ContributorInsightsStatus) {
-    ContributorInsightsStatus["DISABLED"] = "DISABLED";
-    ContributorInsightsStatus["DISABLING"] = "DISABLING";
-    ContributorInsightsStatus["ENABLED"] = "ENABLED";
-    ContributorInsightsStatus["ENABLING"] = "ENABLING";
-    ContributorInsightsStatus["FAILED"] = "FAILED";
-})(ContributorInsightsStatus || (ContributorInsightsStatus = {}));
+export const ContributorInsightsAction = {
+    DISABLE: "DISABLE",
+    ENABLE: "ENABLE",
+};
+export const ContributorInsightsStatus = {
+    DISABLED: "DISABLED",
+    DISABLING: "DISABLING",
+    ENABLED: "ENABLED",
+    ENABLING: "ENABLING",
+    FAILED: "FAILED",
+};
 export class LimitExceededException extends __BaseException {
     constructor(opts) {
         super({
@@ -304,28 +282,25 @@ export class TableNotFoundException extends __BaseException {
         Object.setPrototypeOf(this, TableNotFoundException.prototype);
     }
 }
-export var GlobalTableStatus;
-(function (GlobalTableStatus) {
-    GlobalTableStatus["ACTIVE"] = "ACTIVE";
-    GlobalTableStatus["CREATING"] = "CREATING";
-    GlobalTableStatus["DELETING"] = "DELETING";
-    GlobalTableStatus["UPDATING"] = "UPDATING";
-})(GlobalTableStatus || (GlobalTableStatus = {}));
-export var ReplicaStatus;
-(function (ReplicaStatus) {
-    ReplicaStatus["ACTIVE"] = "ACTIVE";
-    ReplicaStatus["CREATING"] = "CREATING";
-    ReplicaStatus["CREATION_FAILED"] = "CREATION_FAILED";
-    ReplicaStatus["DELETING"] = "DELETING";
-    ReplicaStatus["INACCESSIBLE_ENCRYPTION_CREDENTIALS"] = "INACCESSIBLE_ENCRYPTION_CREDENTIALS";
-    ReplicaStatus["REGION_DISABLED"] = "REGION_DISABLED";
-    ReplicaStatus["UPDATING"] = "UPDATING";
-})(ReplicaStatus || (ReplicaStatus = {}));
-export var TableClass;
-(function (TableClass) {
-    TableClass["STANDARD"] = "STANDARD";
-    TableClass["STANDARD_INFREQUENT_ACCESS"] = "STANDARD_INFREQUENT_ACCESS";
-})(TableClass || (TableClass = {}));
+export const GlobalTableStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    UPDATING: "UPDATING",
+};
+export const ReplicaStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    CREATION_FAILED: "CREATION_FAILED",
+    DELETING: "DELETING",
+    INACCESSIBLE_ENCRYPTION_CREDENTIALS: "INACCESSIBLE_ENCRYPTION_CREDENTIALS",
+    REGION_DISABLED: "REGION_DISABLED",
+    UPDATING: "UPDATING",
+};
+export const TableClass = {
+    STANDARD: "STANDARD",
+    STANDARD_INFREQUENT_ACCESS: "STANDARD_INFREQUENT_ACCESS",
+};
 export class GlobalTableAlreadyExistsException extends __BaseException {
     constructor(opts) {
         super({
@@ -338,23 +313,21 @@ export class GlobalTableAlreadyExistsException extends __BaseException {
         Object.setPrototypeOf(this, GlobalTableAlreadyExistsException.prototype);
     }
 }
-export var IndexStatus;
-(function (IndexStatus) {
-    IndexStatus["ACTIVE"] = "ACTIVE";
-    IndexStatus["CREATING"] = "CREATING";
-    IndexStatus["DELETING"] = "DELETING";
-    IndexStatus["UPDATING"] = "UPDATING";
-})(IndexStatus || (IndexStatus = {}));
-export var TableStatus;
-(function (TableStatus) {
-    TableStatus["ACTIVE"] = "ACTIVE";
-    TableStatus["ARCHIVED"] = "ARCHIVED";
-    TableStatus["ARCHIVING"] = "ARCHIVING";
-    TableStatus["CREATING"] = "CREATING";
-    TableStatus["DELETING"] = "DELETING";
-    TableStatus["INACCESSIBLE_ENCRYPTION_CREDENTIALS"] = "INACCESSIBLE_ENCRYPTION_CREDENTIALS";
-    TableStatus["UPDATING"] = "UPDATING";
-})(TableStatus || (TableStatus = {}));
+export const IndexStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    UPDATING: "UPDATING",
+};
+export const TableStatus = {
+    ACTIVE: "ACTIVE",
+    ARCHIVED: "ARCHIVED",
+    ARCHIVING: "ARCHIVING",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    INACCESSIBLE_ENCRYPTION_CREDENTIALS: "INACCESSIBLE_ENCRYPTION_CREDENTIALS",
+    UPDATING: "UPDATING",
+};
 export class ResourceInUseException extends __BaseException {
     constructor(opts) {
         super({
@@ -367,14 +340,13 @@ export class ResourceInUseException extends __BaseException {
         Object.setPrototypeOf(this, ResourceInUseException.prototype);
     }
 }
-export var ReturnValue;
-(function (ReturnValue) {
-    ReturnValue["ALL_NEW"] = "ALL_NEW";
-    ReturnValue["ALL_OLD"] = "ALL_OLD";
-    ReturnValue["NONE"] = "NONE";
-    ReturnValue["UPDATED_NEW"] = "UPDATED_NEW";
-    ReturnValue["UPDATED_OLD"] = "UPDATED_OLD";
-})(ReturnValue || (ReturnValue = {}));
+export const ReturnValue = {
+    ALL_NEW: "ALL_NEW",
+    ALL_OLD: "ALL_OLD",
+    NONE: "NONE",
+    UPDATED_NEW: "UPDATED_NEW",
+    UPDATED_OLD: "UPDATED_OLD",
+};
 export class TransactionConflictException extends __BaseException {
     constructor(opts) {
         super({
@@ -387,22 +359,19 @@ export class TransactionConflictException extends __BaseException {
         Object.setPrototypeOf(this, TransactionConflictException.prototype);
     }
 }
-export var ExportFormat;
-(function (ExportFormat) {
-    ExportFormat["DYNAMODB_JSON"] = "DYNAMODB_JSON";
-    ExportFormat["ION"] = "ION";
-})(ExportFormat || (ExportFormat = {}));
-export var ExportStatus;
-(function (ExportStatus) {
-    ExportStatus["COMPLETED"] = "COMPLETED";
-    ExportStatus["FAILED"] = "FAILED";
-    ExportStatus["IN_PROGRESS"] = "IN_PROGRESS";
-})(ExportStatus || (ExportStatus = {}));
-export var S3SseAlgorithm;
-(function (S3SseAlgorithm) {
-    S3SseAlgorithm["AES256"] = "AES256";
-    S3SseAlgorithm["KMS"] = "KMS";
-})(S3SseAlgorithm || (S3SseAlgorithm = {}));
+export const ExportFormat = {
+    DYNAMODB_JSON: "DYNAMODB_JSON",
+    ION: "ION",
+};
+export const ExportStatus = {
+    COMPLETED: "COMPLETED",
+    FAILED: "FAILED",
+    IN_PROGRESS: "IN_PROGRESS",
+};
+export const S3SseAlgorithm = {
+    AES256: "AES256",
+    KMS: "KMS",
+};
 export class ExportNotFoundException extends __BaseException {
     constructor(opts) {
         super({
@@ -427,26 +396,23 @@ export class GlobalTableNotFoundException extends __BaseException {
         Object.setPrototypeOf(this, GlobalTableNotFoundException.prototype);
     }
 }
-export var ImportStatus;
-(function (ImportStatus) {
-    ImportStatus["CANCELLED"] = "CANCELLED";
-    ImportStatus["CANCELLING"] = "CANCELLING";
-    ImportStatus["COMPLETED"] = "COMPLETED";
-    ImportStatus["FAILED"] = "FAILED";
-    ImportStatus["IN_PROGRESS"] = "IN_PROGRESS";
-})(ImportStatus || (ImportStatus = {}));
-export var InputCompressionType;
-(function (InputCompressionType) {
-    InputCompressionType["GZIP"] = "GZIP";
-    InputCompressionType["NONE"] = "NONE";
-    InputCompressionType["ZSTD"] = "ZSTD";
-})(InputCompressionType || (InputCompressionType = {}));
-export var InputFormat;
-(function (InputFormat) {
-    InputFormat["CSV"] = "CSV";
-    InputFormat["DYNAMODB_JSON"] = "DYNAMODB_JSON";
-    InputFormat["ION"] = "ION";
-})(InputFormat || (InputFormat = {}));
+export const ImportStatus = {
+    CANCELLED: "CANCELLED",
+    CANCELLING: "CANCELLING",
+    COMPLETED: "COMPLETED",
+    FAILED: "FAILED",
+    IN_PROGRESS: "IN_PROGRESS",
+};
+export const InputCompressionType = {
+    GZIP: "GZIP",
+    NONE: "NONE",
+    ZSTD: "ZSTD",
+};
+export const InputFormat = {
+    CSV: "CSV",
+    DYNAMODB_JSON: "DYNAMODB_JSON",
+    ION: "ION",
+};
 export class ImportNotFoundException extends __BaseException {
     constructor(opts) {
         super({
@@ -459,14 +425,13 @@ export class ImportNotFoundException extends __BaseException {
         Object.setPrototypeOf(this, ImportNotFoundException.prototype);
     }
 }
-export var DestinationStatus;
-(function (DestinationStatus) {
-    DestinationStatus["ACTIVE"] = "ACTIVE";
-    DestinationStatus["DISABLED"] = "DISABLED";
-    DestinationStatus["DISABLING"] = "DISABLING";
-    DestinationStatus["ENABLE_FAILED"] = "ENABLE_FAILED";
-    DestinationStatus["ENABLING"] = "ENABLING";
-})(DestinationStatus || (DestinationStatus = {}));
+export const DestinationStatus = {
+    ACTIVE: "ACTIVE",
+    DISABLED: "DISABLED",
+    DISABLING: "DISABLING",
+    ENABLE_FAILED: "ENABLE_FAILED",
+    ENABLING: "ENABLING",
+};
 export class DuplicateItemException extends __BaseException {
     constructor(opts) {
         super({
@@ -553,13 +518,12 @@ export class ImportConflictException extends __BaseException {
         Object.setPrototypeOf(this, ImportConflictException.prototype);
     }
 }
-export var Select;
-(function (Select) {
-    Select["ALL_ATTRIBUTES"] = "ALL_ATTRIBUTES";
-    Select["ALL_PROJECTED_ATTRIBUTES"] = "ALL_PROJECTED_ATTRIBUTES";
-    Select["COUNT"] = "COUNT";
-    Select["SPECIFIC_ATTRIBUTES"] = "SPECIFIC_ATTRIBUTES";
-})(Select || (Select = {}));
+export const Select = {
+    ALL_ATTRIBUTES: "ALL_ATTRIBUTES",
+    ALL_PROJECTED_ATTRIBUTES: "ALL_PROJECTED_ATTRIBUTES",
+    COUNT: "COUNT",
+    SPECIFIC_ATTRIBUTES: "SPECIFIC_ATTRIBUTES",
+};
 export class TableAlreadyExistsException extends __BaseException {
     constructor(opts) {
         super({

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

@@ -38,26 +38,26 @@ export interface BatchExecuteStatementCommandOutput extends BatchExecuteStatemen
  * import { DynamoDBClient, BatchExecuteStatementCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
  * // const { DynamoDBClient, BatchExecuteStatementCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
  * const client = new DynamoDBClient(config);
- * const input = {
- *   Statements: [ // required
- *     {
+ * const input = { // BatchExecuteStatementInput
+ *   Statements: [ // PartiQLBatchRequest // required
+ *     { // BatchStatementRequest
  *       Statement: "STRING_VALUE", // required
- *       Parameters: [
- *         { // Union: only one key present
+ *       Parameters: [ // PreparedStatementParameters
+ *         { // AttributeValue Union: only one key present
  *           S: "STRING_VALUE",
  *           N: "STRING_VALUE",
  *           B: "BLOB_VALUE",
- *           SS: [
+ *           SS: [ // StringSetAttributeValue
  *             "STRING_VALUE",
  *           ],
- *           NS: [
+ *           NS: [ // NumberSetAttributeValue
  *             "STRING_VALUE",
  *           ],
- *           BS: [
+ *           BS: [ // BinarySetAttributeValue
  *             "BLOB_VALUE",
  *           ],
- *           M: {
- *             "<keys>": { // Union: only one key present
+ *           M: { // MapAttributeValue
+ *             "<keys>": {//  Union: only one key present
  *               S: "STRING_VALUE",
  *               N: "STRING_VALUE",
  *               B: "BLOB_VALUE",
@@ -71,53 +71,20 @@ export interface BatchExecuteStatementCommandOutput extends BatchExecuteStatemen
  *                 "BLOB_VALUE",
  *               ],
  *               M: {
- *                 "<keys>": { // Union: only one key present
- *                   S: "<AttributeValue>",
- *                   N: "<AttributeValue>",
- *                   B: "<AttributeValue>",
- *                   SS: "<AttributeValue>",
- *                   NS: "<AttributeValue>",
- *                   BS: "<AttributeValue>",
- *                   M: "<AttributeValue>",
- *                   L: [
- *                     { // Union: only one key present
- *                       S: "<AttributeValue>",
- *                       N: "<AttributeValue>",
- *                       B: "<AttributeValue>",
- *                       SS: "<AttributeValue>",
- *                       NS: "<AttributeValue>",
- *                       BS: "<AttributeValue>",
- *                       M: "<AttributeValue>",
- *                       L: [
- *                         { // Union: only one key present
- *                           S: "<AttributeValue>",
- *                           N: "<AttributeValue>",
- *                           B: "<AttributeValue>",
- *                           SS: "<AttributeValue>",
- *                           NS: "<AttributeValue>",
- *                           BS: "<AttributeValue>",
- *                           M: "<AttributeValue>",
- *                           L: "<AttributeValue>",
- *                           NULL: true || false,
- *                           BOOL: true || false,
- *                         },
- *                       ],
- *                       NULL: true || false,
- *                       BOOL: true || false,
- *                     },
- *                   ],
- *                   NULL: "<AttributeValue>",
- *                   BOOL: "<AttributeValue>",
- *                 },
+ *                 "<keys>": "<AttributeValue>",
  *               },
- *               L: "<AttributeValue>",
- *               NULL: "<AttributeValue>",
- *               BOOL: "<AttributeValue>",
+ *               L: [ // ListAttributeValue
+ *                 "<AttributeValue>",
+ *               ],
+ *               NULL: true || false,
+ *               BOOL: true || false,
  *             },
  *           },
- *           L: "<AttributeValue>",
- *           NULL: "<AttributeValue>",
- *           BOOL: "<AttributeValue>",
+ *           L: [
+ *             "<AttributeValue>",
+ *           ],
+ *           NULL: true || false,
+ *           BOOL: true || false,
  *         },
  *       ],
  *       ConsistentRead: true || false,