@aws-sdk/client-dynamodb 3.299.0 → 3.300.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist-types/commands/BatchExecuteStatementCommand.d.ts +87 -0
- package/dist-types/commands/BatchGetItemCommand.d.ts +84 -0
- package/dist-types/commands/BatchWriteItemCommand.d.ts +84 -0
- package/dist-types/commands/CreateBackupCommand.d.ts +4 -0
- package/dist-types/commands/CreateGlobalTableCommand.d.ts +8 -0
- package/dist-types/commands/CreateTableCommand.d.ts +75 -0
- package/dist-types/commands/DeleteBackupCommand.d.ts +3 -0
- package/dist-types/commands/DeleteItemCommand.d.ts +113 -0
- package/dist-types/commands/DeleteTableCommand.d.ts +3 -0
- package/dist-types/commands/DescribeBackupCommand.d.ts +3 -0
- package/dist-types/commands/DescribeContinuousBackupsCommand.d.ts +3 -0
- package/dist-types/commands/DescribeContributorInsightsCommand.d.ts +4 -0
- package/dist-types/commands/DescribeEndpointsCommand.d.ts +1 -0
- package/dist-types/commands/DescribeExportCommand.d.ts +3 -0
- package/dist-types/commands/DescribeGlobalTableCommand.d.ts +3 -0
- package/dist-types/commands/DescribeGlobalTableSettingsCommand.d.ts +3 -0
- package/dist-types/commands/DescribeImportCommand.d.ts +3 -0
- package/dist-types/commands/DescribeKinesisStreamingDestinationCommand.d.ts +3 -0
- package/dist-types/commands/DescribeLimitsCommand.d.ts +1 -0
- package/dist-types/commands/DescribeTableCommand.d.ts +3 -0
- package/dist-types/commands/DescribeTableReplicaAutoScalingCommand.d.ts +3 -0
- package/dist-types/commands/DescribeTimeToLiveCommand.d.ts +3 -0
- package/dist-types/commands/DisableKinesisStreamingDestinationCommand.d.ts +4 -0
- package/dist-types/commands/EnableKinesisStreamingDestinationCommand.d.ts +4 -0
- package/dist-types/commands/ExecuteStatementCommand.d.ts +85 -0
- package/dist-types/commands/ExecuteTransactionCommand.d.ts +87 -0
- package/dist-types/commands/ExportTableToPointInTimeCommand.d.ts +11 -0
- package/dist-types/commands/GetItemCommand.d.ts +79 -0
- package/dist-types/commands/ImportTableCommand.d.ts +64 -0
- package/dist-types/commands/ListBackupsCommand.d.ts +8 -0
- package/dist-types/commands/ListContributorInsightsCommand.d.ts +5 -0
- package/dist-types/commands/ListExportsCommand.d.ts +5 -0
- package/dist-types/commands/ListGlobalTablesCommand.d.ts +5 -0
- package/dist-types/commands/ListImportsCommand.d.ts +5 -0
- package/dist-types/commands/ListTablesCommand.d.ts +4 -0
- package/dist-types/commands/ListTagsOfResourceCommand.d.ts +4 -0
- package/dist-types/commands/PutItemCommand.d.ts +113 -0
- package/dist-types/commands/QueryCommand.d.ts +127 -0
- package/dist-types/commands/RestoreTableFromBackupCommand.d.ts +52 -0
- package/dist-types/commands/RestoreTableToPointInTimeCommand.d.ts +55 -0
- package/dist-types/commands/ScanCommand.d.ts +108 -0
- package/dist-types/commands/TagResourceCommand.d.ts +9 -0
- package/dist-types/commands/TransactGetItemsCommand.d.ts +81 -0
- package/dist-types/commands/TransactWriteItemsCommand.d.ts +130 -0
- package/dist-types/commands/UntagResourceCommand.d.ts +6 -0
- package/dist-types/commands/UpdateContinuousBackupsCommand.d.ts +6 -0
- package/dist-types/commands/UpdateContributorInsightsCommand.d.ts +5 -0
- package/dist-types/commands/UpdateGlobalTableCommand.d.ts +13 -0
- package/dist-types/commands/UpdateGlobalTableSettingsCommand.d.ts +76 -0
- package/dist-types/commands/UpdateItemCommand.d.ts +131 -0
- package/dist-types/commands/UpdateTableCommand.d.ts +97 -0
- package/dist-types/commands/UpdateTableReplicaAutoScalingCommand.d.ts +62 -0
- package/dist-types/commands/UpdateTimeToLiveCommand.d.ts +7 -0
- package/package.json +9 -9
|
@@ -76,6 +76,133 @@ export interface QueryCommandOutput extends QueryOutput, __MetadataBearer {
|
|
|
76
76
|
* import { DynamoDBClient, QueryCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
|
|
77
77
|
* // const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
|
|
78
78
|
* const client = new DynamoDBClient(config);
|
|
79
|
+
* const input = {
|
|
80
|
+
* TableName: "STRING_VALUE", // required
|
|
81
|
+
* IndexName: "STRING_VALUE",
|
|
82
|
+
* Select: "ALL_ATTRIBUTES" || "ALL_PROJECTED_ATTRIBUTES" || "SPECIFIC_ATTRIBUTES" || "COUNT",
|
|
83
|
+
* AttributesToGet: [
|
|
84
|
+
* "STRING_VALUE",
|
|
85
|
+
* ],
|
|
86
|
+
* Limit: Number("int"),
|
|
87
|
+
* ConsistentRead: true || false,
|
|
88
|
+
* KeyConditions: {
|
|
89
|
+
* "<keys>": {
|
|
90
|
+
* AttributeValueList: [
|
|
91
|
+
* { // Union: only one key present
|
|
92
|
+
* S: "STRING_VALUE",
|
|
93
|
+
* N: "STRING_VALUE",
|
|
94
|
+
* B: "BLOB_VALUE",
|
|
95
|
+
* SS: [
|
|
96
|
+
* "STRING_VALUE",
|
|
97
|
+
* ],
|
|
98
|
+
* NS: [
|
|
99
|
+
* "STRING_VALUE",
|
|
100
|
+
* ],
|
|
101
|
+
* BS: [
|
|
102
|
+
* "BLOB_VALUE",
|
|
103
|
+
* ],
|
|
104
|
+
* M: {
|
|
105
|
+
* "<keys>": { // Union: only one key present
|
|
106
|
+
* S: "STRING_VALUE",
|
|
107
|
+
* N: "STRING_VALUE",
|
|
108
|
+
* B: "BLOB_VALUE",
|
|
109
|
+
* SS: [
|
|
110
|
+
* "STRING_VALUE",
|
|
111
|
+
* ],
|
|
112
|
+
* NS: [
|
|
113
|
+
* "STRING_VALUE",
|
|
114
|
+
* ],
|
|
115
|
+
* BS: [
|
|
116
|
+
* "BLOB_VALUE",
|
|
117
|
+
* ],
|
|
118
|
+
* M: {
|
|
119
|
+
* "<keys>": { // Union: only one key present
|
|
120
|
+
* S: "<AttributeValue>",
|
|
121
|
+
* N: "<AttributeValue>",
|
|
122
|
+
* B: "<AttributeValue>",
|
|
123
|
+
* SS: "<AttributeValue>",
|
|
124
|
+
* NS: "<AttributeValue>",
|
|
125
|
+
* BS: "<AttributeValue>",
|
|
126
|
+
* M: "<AttributeValue>",
|
|
127
|
+
* L: [
|
|
128
|
+
* { // Union: only one key present
|
|
129
|
+
* S: "<AttributeValue>",
|
|
130
|
+
* N: "<AttributeValue>",
|
|
131
|
+
* B: "<AttributeValue>",
|
|
132
|
+
* SS: "<AttributeValue>",
|
|
133
|
+
* NS: "<AttributeValue>",
|
|
134
|
+
* BS: "<AttributeValue>",
|
|
135
|
+
* M: "<AttributeValue>",
|
|
136
|
+
* L: [
|
|
137
|
+
* { // Union: only one key present
|
|
138
|
+
* S: "<AttributeValue>",
|
|
139
|
+
* N: "<AttributeValue>",
|
|
140
|
+
* B: "<AttributeValue>",
|
|
141
|
+
* SS: "<AttributeValue>",
|
|
142
|
+
* NS: "<AttributeValue>",
|
|
143
|
+
* BS: "<AttributeValue>",
|
|
144
|
+
* M: "<AttributeValue>",
|
|
145
|
+
* L: "<AttributeValue>",
|
|
146
|
+
* NULL: true || false,
|
|
147
|
+
* BOOL: true || false,
|
|
148
|
+
* },
|
|
149
|
+
* ],
|
|
150
|
+
* NULL: true || false,
|
|
151
|
+
* BOOL: true || false,
|
|
152
|
+
* },
|
|
153
|
+
* ],
|
|
154
|
+
* NULL: "<AttributeValue>",
|
|
155
|
+
* BOOL: "<AttributeValue>",
|
|
156
|
+
* },
|
|
157
|
+
* },
|
|
158
|
+
* L: "<AttributeValue>",
|
|
159
|
+
* NULL: "<AttributeValue>",
|
|
160
|
+
* BOOL: "<AttributeValue>",
|
|
161
|
+
* },
|
|
162
|
+
* },
|
|
163
|
+
* L: "<AttributeValue>",
|
|
164
|
+
* NULL: "<AttributeValue>",
|
|
165
|
+
* BOOL: "<AttributeValue>",
|
|
166
|
+
* },
|
|
167
|
+
* ],
|
|
168
|
+
* ComparisonOperator: "EQ" || "NE" || "IN" || "LE" || "LT" || "GE" || "GT" || "BETWEEN" || "NOT_NULL" || "NULL" || "CONTAINS" || "NOT_CONTAINS" || "BEGINS_WITH", // required
|
|
169
|
+
* },
|
|
170
|
+
* },
|
|
171
|
+
* QueryFilter: {
|
|
172
|
+
* "<keys>": {
|
|
173
|
+
* AttributeValueList: [
|
|
174
|
+
* { // Union: only one key present
|
|
175
|
+
* S: "<AttributeValue>",
|
|
176
|
+
* N: "<AttributeValue>",
|
|
177
|
+
* B: "<AttributeValue>",
|
|
178
|
+
* SS: "<AttributeValue>",
|
|
179
|
+
* NS: "<AttributeValue>",
|
|
180
|
+
* BS: "<AttributeValue>",
|
|
181
|
+
* M: "<AttributeValue>",
|
|
182
|
+
* L: "<AttributeValue>",
|
|
183
|
+
* NULL: "<AttributeValue>",
|
|
184
|
+
* BOOL: "<AttributeValue>",
|
|
185
|
+
* },
|
|
186
|
+
* ],
|
|
187
|
+
* ComparisonOperator: "EQ" || "NE" || "IN" || "LE" || "LT" || "GE" || "GT" || "BETWEEN" || "NOT_NULL" || "NULL" || "CONTAINS" || "NOT_CONTAINS" || "BEGINS_WITH", // required
|
|
188
|
+
* },
|
|
189
|
+
* },
|
|
190
|
+
* ConditionalOperator: "AND" || "OR",
|
|
191
|
+
* ScanIndexForward: true || false,
|
|
192
|
+
* ExclusiveStartKey: {
|
|
193
|
+
* "<keys>": "<AttributeValue>",
|
|
194
|
+
* },
|
|
195
|
+
* ReturnConsumedCapacity: "INDEXES" || "TOTAL" || "NONE",
|
|
196
|
+
* ProjectionExpression: "STRING_VALUE",
|
|
197
|
+
* FilterExpression: "STRING_VALUE",
|
|
198
|
+
* KeyConditionExpression: "STRING_VALUE",
|
|
199
|
+
* ExpressionAttributeNames: {
|
|
200
|
+
* "<keys>": "STRING_VALUE",
|
|
201
|
+
* },
|
|
202
|
+
* ExpressionAttributeValues: {
|
|
203
|
+
* "<keys>": "<AttributeValue>",
|
|
204
|
+
* },
|
|
205
|
+
* };
|
|
79
206
|
* const command = new QueryCommand(input);
|
|
80
207
|
* const response = await client.send(command);
|
|
81
208
|
* ```
|
|
@@ -50,6 +50,58 @@ export interface RestoreTableFromBackupCommandOutput extends RestoreTableFromBac
|
|
|
50
50
|
* import { DynamoDBClient, RestoreTableFromBackupCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
|
|
51
51
|
* // const { DynamoDBClient, RestoreTableFromBackupCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
|
|
52
52
|
* const client = new DynamoDBClient(config);
|
|
53
|
+
* const input = {
|
|
54
|
+
* TargetTableName: "STRING_VALUE", // required
|
|
55
|
+
* BackupArn: "STRING_VALUE", // required
|
|
56
|
+
* BillingModeOverride: "PROVISIONED" || "PAY_PER_REQUEST",
|
|
57
|
+
* GlobalSecondaryIndexOverride: [
|
|
58
|
+
* {
|
|
59
|
+
* IndexName: "STRING_VALUE", // required
|
|
60
|
+
* KeySchema: [ // required
|
|
61
|
+
* {
|
|
62
|
+
* AttributeName: "STRING_VALUE", // required
|
|
63
|
+
* KeyType: "HASH" || "RANGE", // required
|
|
64
|
+
* },
|
|
65
|
+
* ],
|
|
66
|
+
* Projection: {
|
|
67
|
+
* ProjectionType: "ALL" || "KEYS_ONLY" || "INCLUDE",
|
|
68
|
+
* NonKeyAttributes: [
|
|
69
|
+
* "STRING_VALUE",
|
|
70
|
+
* ],
|
|
71
|
+
* },
|
|
72
|
+
* ProvisionedThroughput: {
|
|
73
|
+
* ReadCapacityUnits: Number("long"), // required
|
|
74
|
+
* WriteCapacityUnits: Number("long"), // required
|
|
75
|
+
* },
|
|
76
|
+
* },
|
|
77
|
+
* ],
|
|
78
|
+
* LocalSecondaryIndexOverride: [
|
|
79
|
+
* {
|
|
80
|
+
* IndexName: "STRING_VALUE", // required
|
|
81
|
+
* KeySchema: [ // required
|
|
82
|
+
* {
|
|
83
|
+
* AttributeName: "STRING_VALUE", // required
|
|
84
|
+
* KeyType: "HASH" || "RANGE", // required
|
|
85
|
+
* },
|
|
86
|
+
* ],
|
|
87
|
+
* Projection: {
|
|
88
|
+
* ProjectionType: "ALL" || "KEYS_ONLY" || "INCLUDE",
|
|
89
|
+
* NonKeyAttributes: [
|
|
90
|
+
* "STRING_VALUE",
|
|
91
|
+
* ],
|
|
92
|
+
* },
|
|
93
|
+
* },
|
|
94
|
+
* ],
|
|
95
|
+
* ProvisionedThroughputOverride: {
|
|
96
|
+
* ReadCapacityUnits: Number("long"), // required
|
|
97
|
+
* WriteCapacityUnits: Number("long"), // required
|
|
98
|
+
* },
|
|
99
|
+
* SSESpecificationOverride: {
|
|
100
|
+
* Enabled: true || false,
|
|
101
|
+
* SSEType: "AES256" || "KMS",
|
|
102
|
+
* KMSMasterKeyId: "STRING_VALUE",
|
|
103
|
+
* },
|
|
104
|
+
* };
|
|
53
105
|
* const command = new RestoreTableFromBackupCommand(input);
|
|
54
106
|
* const response = await client.send(command);
|
|
55
107
|
* ```
|
|
@@ -75,6 +75,61 @@ export interface RestoreTableToPointInTimeCommandOutput extends RestoreTableToPo
|
|
|
75
75
|
* import { DynamoDBClient, RestoreTableToPointInTimeCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
|
|
76
76
|
* // const { DynamoDBClient, RestoreTableToPointInTimeCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
|
|
77
77
|
* const client = new DynamoDBClient(config);
|
|
78
|
+
* const input = {
|
|
79
|
+
* SourceTableArn: "STRING_VALUE",
|
|
80
|
+
* SourceTableName: "STRING_VALUE",
|
|
81
|
+
* TargetTableName: "STRING_VALUE", // required
|
|
82
|
+
* UseLatestRestorableTime: true || false,
|
|
83
|
+
* RestoreDateTime: new Date("TIMESTAMP"),
|
|
84
|
+
* BillingModeOverride: "PROVISIONED" || "PAY_PER_REQUEST",
|
|
85
|
+
* GlobalSecondaryIndexOverride: [
|
|
86
|
+
* {
|
|
87
|
+
* IndexName: "STRING_VALUE", // required
|
|
88
|
+
* KeySchema: [ // required
|
|
89
|
+
* {
|
|
90
|
+
* AttributeName: "STRING_VALUE", // required
|
|
91
|
+
* KeyType: "HASH" || "RANGE", // required
|
|
92
|
+
* },
|
|
93
|
+
* ],
|
|
94
|
+
* Projection: {
|
|
95
|
+
* ProjectionType: "ALL" || "KEYS_ONLY" || "INCLUDE",
|
|
96
|
+
* NonKeyAttributes: [
|
|
97
|
+
* "STRING_VALUE",
|
|
98
|
+
* ],
|
|
99
|
+
* },
|
|
100
|
+
* ProvisionedThroughput: {
|
|
101
|
+
* ReadCapacityUnits: Number("long"), // required
|
|
102
|
+
* WriteCapacityUnits: Number("long"), // required
|
|
103
|
+
* },
|
|
104
|
+
* },
|
|
105
|
+
* ],
|
|
106
|
+
* LocalSecondaryIndexOverride: [
|
|
107
|
+
* {
|
|
108
|
+
* IndexName: "STRING_VALUE", // required
|
|
109
|
+
* KeySchema: [ // required
|
|
110
|
+
* {
|
|
111
|
+
* AttributeName: "STRING_VALUE", // required
|
|
112
|
+
* KeyType: "HASH" || "RANGE", // required
|
|
113
|
+
* },
|
|
114
|
+
* ],
|
|
115
|
+
* Projection: {
|
|
116
|
+
* ProjectionType: "ALL" || "KEYS_ONLY" || "INCLUDE",
|
|
117
|
+
* NonKeyAttributes: [
|
|
118
|
+
* "STRING_VALUE",
|
|
119
|
+
* ],
|
|
120
|
+
* },
|
|
121
|
+
* },
|
|
122
|
+
* ],
|
|
123
|
+
* ProvisionedThroughputOverride: {
|
|
124
|
+
* ReadCapacityUnits: Number("long"), // required
|
|
125
|
+
* WriteCapacityUnits: Number("long"), // required
|
|
126
|
+
* },
|
|
127
|
+
* SSESpecificationOverride: {
|
|
128
|
+
* Enabled: true || false,
|
|
129
|
+
* SSEType: "AES256" || "KMS",
|
|
130
|
+
* KMSMasterKeyId: "STRING_VALUE",
|
|
131
|
+
* },
|
|
132
|
+
* };
|
|
78
133
|
* const command = new RestoreTableToPointInTimeCommand(input);
|
|
79
134
|
* const response = await client.send(command);
|
|
80
135
|
* ```
|
|
@@ -51,6 +51,114 @@ export interface ScanCommandOutput extends ScanOutput, __MetadataBearer {
|
|
|
51
51
|
* import { DynamoDBClient, ScanCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
|
|
52
52
|
* // const { DynamoDBClient, ScanCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
|
|
53
53
|
* const client = new DynamoDBClient(config);
|
|
54
|
+
* const input = {
|
|
55
|
+
* TableName: "STRING_VALUE", // required
|
|
56
|
+
* IndexName: "STRING_VALUE",
|
|
57
|
+
* AttributesToGet: [
|
|
58
|
+
* "STRING_VALUE",
|
|
59
|
+
* ],
|
|
60
|
+
* Limit: Number("int"),
|
|
61
|
+
* Select: "ALL_ATTRIBUTES" || "ALL_PROJECTED_ATTRIBUTES" || "SPECIFIC_ATTRIBUTES" || "COUNT",
|
|
62
|
+
* ScanFilter: {
|
|
63
|
+
* "<keys>": {
|
|
64
|
+
* AttributeValueList: [
|
|
65
|
+
* { // Union: only one key present
|
|
66
|
+
* S: "STRING_VALUE",
|
|
67
|
+
* N: "STRING_VALUE",
|
|
68
|
+
* B: "BLOB_VALUE",
|
|
69
|
+
* SS: [
|
|
70
|
+
* "STRING_VALUE",
|
|
71
|
+
* ],
|
|
72
|
+
* NS: [
|
|
73
|
+
* "STRING_VALUE",
|
|
74
|
+
* ],
|
|
75
|
+
* BS: [
|
|
76
|
+
* "BLOB_VALUE",
|
|
77
|
+
* ],
|
|
78
|
+
* M: {
|
|
79
|
+
* "<keys>": { // Union: only one key present
|
|
80
|
+
* S: "STRING_VALUE",
|
|
81
|
+
* N: "STRING_VALUE",
|
|
82
|
+
* B: "BLOB_VALUE",
|
|
83
|
+
* SS: [
|
|
84
|
+
* "STRING_VALUE",
|
|
85
|
+
* ],
|
|
86
|
+
* NS: [
|
|
87
|
+
* "STRING_VALUE",
|
|
88
|
+
* ],
|
|
89
|
+
* BS: [
|
|
90
|
+
* "BLOB_VALUE",
|
|
91
|
+
* ],
|
|
92
|
+
* M: {
|
|
93
|
+
* "<keys>": { // Union: only one key present
|
|
94
|
+
* S: "<AttributeValue>",
|
|
95
|
+
* N: "<AttributeValue>",
|
|
96
|
+
* B: "<AttributeValue>",
|
|
97
|
+
* SS: "<AttributeValue>",
|
|
98
|
+
* NS: "<AttributeValue>",
|
|
99
|
+
* BS: "<AttributeValue>",
|
|
100
|
+
* M: "<AttributeValue>",
|
|
101
|
+
* L: [
|
|
102
|
+
* { // Union: only one key present
|
|
103
|
+
* S: "<AttributeValue>",
|
|
104
|
+
* N: "<AttributeValue>",
|
|
105
|
+
* B: "<AttributeValue>",
|
|
106
|
+
* SS: "<AttributeValue>",
|
|
107
|
+
* NS: "<AttributeValue>",
|
|
108
|
+
* BS: "<AttributeValue>",
|
|
109
|
+
* M: "<AttributeValue>",
|
|
110
|
+
* L: [
|
|
111
|
+
* { // Union: only one key present
|
|
112
|
+
* S: "<AttributeValue>",
|
|
113
|
+
* N: "<AttributeValue>",
|
|
114
|
+
* B: "<AttributeValue>",
|
|
115
|
+
* SS: "<AttributeValue>",
|
|
116
|
+
* NS: "<AttributeValue>",
|
|
117
|
+
* BS: "<AttributeValue>",
|
|
118
|
+
* M: "<AttributeValue>",
|
|
119
|
+
* L: "<AttributeValue>",
|
|
120
|
+
* NULL: true || false,
|
|
121
|
+
* BOOL: true || false,
|
|
122
|
+
* },
|
|
123
|
+
* ],
|
|
124
|
+
* NULL: true || false,
|
|
125
|
+
* BOOL: true || false,
|
|
126
|
+
* },
|
|
127
|
+
* ],
|
|
128
|
+
* NULL: "<AttributeValue>",
|
|
129
|
+
* BOOL: "<AttributeValue>",
|
|
130
|
+
* },
|
|
131
|
+
* },
|
|
132
|
+
* L: "<AttributeValue>",
|
|
133
|
+
* NULL: "<AttributeValue>",
|
|
134
|
+
* BOOL: "<AttributeValue>",
|
|
135
|
+
* },
|
|
136
|
+
* },
|
|
137
|
+
* L: "<AttributeValue>",
|
|
138
|
+
* NULL: "<AttributeValue>",
|
|
139
|
+
* BOOL: "<AttributeValue>",
|
|
140
|
+
* },
|
|
141
|
+
* ],
|
|
142
|
+
* ComparisonOperator: "EQ" || "NE" || "IN" || "LE" || "LT" || "GE" || "GT" || "BETWEEN" || "NOT_NULL" || "NULL" || "CONTAINS" || "NOT_CONTAINS" || "BEGINS_WITH", // required
|
|
143
|
+
* },
|
|
144
|
+
* },
|
|
145
|
+
* ConditionalOperator: "AND" || "OR",
|
|
146
|
+
* ExclusiveStartKey: {
|
|
147
|
+
* "<keys>": "<AttributeValue>",
|
|
148
|
+
* },
|
|
149
|
+
* ReturnConsumedCapacity: "INDEXES" || "TOTAL" || "NONE",
|
|
150
|
+
* TotalSegments: Number("int"),
|
|
151
|
+
* Segment: Number("int"),
|
|
152
|
+
* ProjectionExpression: "STRING_VALUE",
|
|
153
|
+
* FilterExpression: "STRING_VALUE",
|
|
154
|
+
* ExpressionAttributeNames: {
|
|
155
|
+
* "<keys>": "STRING_VALUE",
|
|
156
|
+
* },
|
|
157
|
+
* ExpressionAttributeValues: {
|
|
158
|
+
* "<keys>": "<AttributeValue>",
|
|
159
|
+
* },
|
|
160
|
+
* ConsistentRead: true || false,
|
|
161
|
+
* };
|
|
54
162
|
* const command = new ScanCommand(input);
|
|
55
163
|
* const response = await client.send(command);
|
|
56
164
|
* ```
|
|
@@ -31,6 +31,15 @@ export interface TagResourceCommandOutput extends __MetadataBearer {
|
|
|
31
31
|
* import { DynamoDBClient, TagResourceCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
|
|
32
32
|
* // const { DynamoDBClient, TagResourceCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
|
|
33
33
|
* const client = new DynamoDBClient(config);
|
|
34
|
+
* const input = {
|
|
35
|
+
* ResourceArn: "STRING_VALUE", // required
|
|
36
|
+
* Tags: [ // required
|
|
37
|
+
* {
|
|
38
|
+
* Key: "STRING_VALUE", // required
|
|
39
|
+
* Value: "STRING_VALUE", // required
|
|
40
|
+
* },
|
|
41
|
+
* ],
|
|
42
|
+
* };
|
|
34
43
|
* const command = new TagResourceCommand(input);
|
|
35
44
|
* const response = await client.send(command);
|
|
36
45
|
* ```
|
|
@@ -52,6 +52,87 @@ export interface TransactGetItemsCommandOutput extends TransactGetItemsOutput, _
|
|
|
52
52
|
* import { DynamoDBClient, TransactGetItemsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
|
|
53
53
|
* // const { DynamoDBClient, TransactGetItemsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
|
|
54
54
|
* const client = new DynamoDBClient(config);
|
|
55
|
+
* const input = {
|
|
56
|
+
* TransactItems: [ // required
|
|
57
|
+
* {
|
|
58
|
+
* Get: {
|
|
59
|
+
* Key: { // required
|
|
60
|
+
* "<keys>": { // Union: only one key present
|
|
61
|
+
* S: "STRING_VALUE",
|
|
62
|
+
* N: "STRING_VALUE",
|
|
63
|
+
* B: "BLOB_VALUE",
|
|
64
|
+
* SS: [
|
|
65
|
+
* "STRING_VALUE",
|
|
66
|
+
* ],
|
|
67
|
+
* NS: [
|
|
68
|
+
* "STRING_VALUE",
|
|
69
|
+
* ],
|
|
70
|
+
* BS: [
|
|
71
|
+
* "BLOB_VALUE",
|
|
72
|
+
* ],
|
|
73
|
+
* M: {
|
|
74
|
+
* "<keys>": { // Union: only one key present
|
|
75
|
+
* S: "STRING_VALUE",
|
|
76
|
+
* N: "STRING_VALUE",
|
|
77
|
+
* B: "BLOB_VALUE",
|
|
78
|
+
* SS: [
|
|
79
|
+
* "STRING_VALUE",
|
|
80
|
+
* ],
|
|
81
|
+
* NS: [
|
|
82
|
+
* "STRING_VALUE",
|
|
83
|
+
* ],
|
|
84
|
+
* BS: [
|
|
85
|
+
* "BLOB_VALUE",
|
|
86
|
+
* ],
|
|
87
|
+
* M: {
|
|
88
|
+
* "<keys>": "<AttributeValue>",
|
|
89
|
+
* },
|
|
90
|
+
* L: [
|
|
91
|
+
* { // Union: only one key present
|
|
92
|
+
* S: "<AttributeValue>",
|
|
93
|
+
* N: "<AttributeValue>",
|
|
94
|
+
* B: "<AttributeValue>",
|
|
95
|
+
* SS: "<AttributeValue>",
|
|
96
|
+
* NS: "<AttributeValue>",
|
|
97
|
+
* BS: "<AttributeValue>",
|
|
98
|
+
* M: "<AttributeValue>",
|
|
99
|
+
* L: [
|
|
100
|
+
* { // Union: only one key present
|
|
101
|
+
* S: "<AttributeValue>",
|
|
102
|
+
* N: "<AttributeValue>",
|
|
103
|
+
* B: "<AttributeValue>",
|
|
104
|
+
* SS: "<AttributeValue>",
|
|
105
|
+
* NS: "<AttributeValue>",
|
|
106
|
+
* BS: "<AttributeValue>",
|
|
107
|
+
* M: "<AttributeValue>",
|
|
108
|
+
* L: "<AttributeValue>",
|
|
109
|
+
* NULL: true || false,
|
|
110
|
+
* BOOL: true || false,
|
|
111
|
+
* },
|
|
112
|
+
* ],
|
|
113
|
+
* NULL: true || false,
|
|
114
|
+
* BOOL: true || false,
|
|
115
|
+
* },
|
|
116
|
+
* ],
|
|
117
|
+
* NULL: "<AttributeValue>",
|
|
118
|
+
* BOOL: "<AttributeValue>",
|
|
119
|
+
* },
|
|
120
|
+
* },
|
|
121
|
+
* L: "<AttributeValue>",
|
|
122
|
+
* NULL: "<AttributeValue>",
|
|
123
|
+
* BOOL: "<AttributeValue>",
|
|
124
|
+
* },
|
|
125
|
+
* },
|
|
126
|
+
* TableName: "STRING_VALUE", // required
|
|
127
|
+
* ProjectionExpression: "STRING_VALUE",
|
|
128
|
+
* ExpressionAttributeNames: {
|
|
129
|
+
* "<keys>": "STRING_VALUE",
|
|
130
|
+
* },
|
|
131
|
+
* },
|
|
132
|
+
* },
|
|
133
|
+
* ],
|
|
134
|
+
* ReturnConsumedCapacity: "INDEXES" || "TOTAL" || "NONE",
|
|
135
|
+
* };
|
|
55
136
|
* const command = new TransactGetItemsCommand(input);
|
|
56
137
|
* const response = await client.send(command);
|
|
57
138
|
* ```
|
|
@@ -98,6 +98,136 @@ export interface TransactWriteItemsCommandOutput extends TransactWriteItemsOutpu
|
|
|
98
98
|
* import { DynamoDBClient, TransactWriteItemsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
|
|
99
99
|
* // const { DynamoDBClient, TransactWriteItemsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
|
|
100
100
|
* const client = new DynamoDBClient(config);
|
|
101
|
+
* const input = {
|
|
102
|
+
* TransactItems: [ // required
|
|
103
|
+
* {
|
|
104
|
+
* ConditionCheck: {
|
|
105
|
+
* Key: { // required
|
|
106
|
+
* "<keys>": { // Union: only one key present
|
|
107
|
+
* S: "STRING_VALUE",
|
|
108
|
+
* N: "STRING_VALUE",
|
|
109
|
+
* B: "BLOB_VALUE",
|
|
110
|
+
* SS: [
|
|
111
|
+
* "STRING_VALUE",
|
|
112
|
+
* ],
|
|
113
|
+
* NS: [
|
|
114
|
+
* "STRING_VALUE",
|
|
115
|
+
* ],
|
|
116
|
+
* BS: [
|
|
117
|
+
* "BLOB_VALUE",
|
|
118
|
+
* ],
|
|
119
|
+
* M: {
|
|
120
|
+
* "<keys>": { // Union: only one key present
|
|
121
|
+
* S: "STRING_VALUE",
|
|
122
|
+
* N: "STRING_VALUE",
|
|
123
|
+
* B: "BLOB_VALUE",
|
|
124
|
+
* SS: [
|
|
125
|
+
* "STRING_VALUE",
|
|
126
|
+
* ],
|
|
127
|
+
* NS: [
|
|
128
|
+
* "STRING_VALUE",
|
|
129
|
+
* ],
|
|
130
|
+
* BS: [
|
|
131
|
+
* "BLOB_VALUE",
|
|
132
|
+
* ],
|
|
133
|
+
* M: {
|
|
134
|
+
* "<keys>": "<AttributeValue>",
|
|
135
|
+
* },
|
|
136
|
+
* L: [
|
|
137
|
+
* { // Union: only one key present
|
|
138
|
+
* S: "<AttributeValue>",
|
|
139
|
+
* N: "<AttributeValue>",
|
|
140
|
+
* B: "<AttributeValue>",
|
|
141
|
+
* SS: "<AttributeValue>",
|
|
142
|
+
* NS: "<AttributeValue>",
|
|
143
|
+
* BS: "<AttributeValue>",
|
|
144
|
+
* M: "<AttributeValue>",
|
|
145
|
+
* L: [
|
|
146
|
+
* { // Union: only one key present
|
|
147
|
+
* S: "<AttributeValue>",
|
|
148
|
+
* N: "<AttributeValue>",
|
|
149
|
+
* B: "<AttributeValue>",
|
|
150
|
+
* SS: "<AttributeValue>",
|
|
151
|
+
* NS: "<AttributeValue>",
|
|
152
|
+
* BS: "<AttributeValue>",
|
|
153
|
+
* M: "<AttributeValue>",
|
|
154
|
+
* L: "<AttributeValue>",
|
|
155
|
+
* NULL: true || false,
|
|
156
|
+
* BOOL: true || false,
|
|
157
|
+
* },
|
|
158
|
+
* ],
|
|
159
|
+
* NULL: true || false,
|
|
160
|
+
* BOOL: true || false,
|
|
161
|
+
* },
|
|
162
|
+
* ],
|
|
163
|
+
* NULL: "<AttributeValue>",
|
|
164
|
+
* BOOL: "<AttributeValue>",
|
|
165
|
+
* },
|
|
166
|
+
* },
|
|
167
|
+
* L: "<AttributeValue>",
|
|
168
|
+
* NULL: "<AttributeValue>",
|
|
169
|
+
* BOOL: "<AttributeValue>",
|
|
170
|
+
* },
|
|
171
|
+
* },
|
|
172
|
+
* TableName: "STRING_VALUE", // required
|
|
173
|
+
* ConditionExpression: "STRING_VALUE", // required
|
|
174
|
+
* ExpressionAttributeNames: {
|
|
175
|
+
* "<keys>": "STRING_VALUE",
|
|
176
|
+
* },
|
|
177
|
+
* ExpressionAttributeValues: {
|
|
178
|
+
* "<keys>": "<AttributeValue>",
|
|
179
|
+
* },
|
|
180
|
+
* ReturnValuesOnConditionCheckFailure: "ALL_OLD" || "NONE",
|
|
181
|
+
* },
|
|
182
|
+
* Put: {
|
|
183
|
+
* Item: { // required
|
|
184
|
+
* "<keys>": "<AttributeValue>",
|
|
185
|
+
* },
|
|
186
|
+
* TableName: "STRING_VALUE", // required
|
|
187
|
+
* ConditionExpression: "STRING_VALUE",
|
|
188
|
+
* ExpressionAttributeNames: {
|
|
189
|
+
* "<keys>": "STRING_VALUE",
|
|
190
|
+
* },
|
|
191
|
+
* ExpressionAttributeValues: {
|
|
192
|
+
* "<keys>": "<AttributeValue>",
|
|
193
|
+
* },
|
|
194
|
+
* ReturnValuesOnConditionCheckFailure: "ALL_OLD" || "NONE",
|
|
195
|
+
* },
|
|
196
|
+
* Delete: {
|
|
197
|
+
* Key: { // required
|
|
198
|
+
* "<keys>": "<AttributeValue>",
|
|
199
|
+
* },
|
|
200
|
+
* TableName: "STRING_VALUE", // required
|
|
201
|
+
* ConditionExpression: "STRING_VALUE",
|
|
202
|
+
* ExpressionAttributeNames: {
|
|
203
|
+
* "<keys>": "STRING_VALUE",
|
|
204
|
+
* },
|
|
205
|
+
* ExpressionAttributeValues: {
|
|
206
|
+
* "<keys>": "<AttributeValue>",
|
|
207
|
+
* },
|
|
208
|
+
* ReturnValuesOnConditionCheckFailure: "ALL_OLD" || "NONE",
|
|
209
|
+
* },
|
|
210
|
+
* Update: {
|
|
211
|
+
* Key: { // required
|
|
212
|
+
* "<keys>": "<AttributeValue>",
|
|
213
|
+
* },
|
|
214
|
+
* UpdateExpression: "STRING_VALUE", // required
|
|
215
|
+
* TableName: "STRING_VALUE", // required
|
|
216
|
+
* ConditionExpression: "STRING_VALUE",
|
|
217
|
+
* ExpressionAttributeNames: {
|
|
218
|
+
* "<keys>": "STRING_VALUE",
|
|
219
|
+
* },
|
|
220
|
+
* ExpressionAttributeValues: {
|
|
221
|
+
* "<keys>": "<AttributeValue>",
|
|
222
|
+
* },
|
|
223
|
+
* ReturnValuesOnConditionCheckFailure: "ALL_OLD" || "NONE",
|
|
224
|
+
* },
|
|
225
|
+
* },
|
|
226
|
+
* ],
|
|
227
|
+
* ReturnConsumedCapacity: "INDEXES" || "TOTAL" || "NONE",
|
|
228
|
+
* ReturnItemCollectionMetrics: "SIZE" || "NONE",
|
|
229
|
+
* ClientRequestToken: "STRING_VALUE",
|
|
230
|
+
* };
|
|
101
231
|
* const command = new TransactWriteItemsCommand(input);
|
|
102
232
|
* const response = await client.send(command);
|
|
103
233
|
* ```
|
|
@@ -29,6 +29,12 @@ export interface UntagResourceCommandOutput extends __MetadataBearer {
|
|
|
29
29
|
* import { DynamoDBClient, UntagResourceCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
|
|
30
30
|
* // const { DynamoDBClient, UntagResourceCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
|
|
31
31
|
* const client = new DynamoDBClient(config);
|
|
32
|
+
* const input = {
|
|
33
|
+
* ResourceArn: "STRING_VALUE", // required
|
|
34
|
+
* TagKeys: [ // required
|
|
35
|
+
* "STRING_VALUE",
|
|
36
|
+
* ],
|
|
37
|
+
* };
|
|
32
38
|
* const command = new UntagResourceCommand(input);
|
|
33
39
|
* const response = await client.send(command);
|
|
34
40
|
* ```
|
|
@@ -37,6 +37,12 @@ export interface UpdateContinuousBackupsCommandOutput extends UpdateContinuousBa
|
|
|
37
37
|
* import { DynamoDBClient, UpdateContinuousBackupsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
|
|
38
38
|
* // const { DynamoDBClient, UpdateContinuousBackupsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
|
|
39
39
|
* const client = new DynamoDBClient(config);
|
|
40
|
+
* const input = {
|
|
41
|
+
* TableName: "STRING_VALUE", // required
|
|
42
|
+
* PointInTimeRecoverySpecification: {
|
|
43
|
+
* PointInTimeRecoveryEnabled: true || false, // required
|
|
44
|
+
* },
|
|
45
|
+
* };
|
|
40
46
|
* const command = new UpdateContinuousBackupsCommand(input);
|
|
41
47
|
* const response = await client.send(command);
|
|
42
48
|
* ```
|
|
@@ -32,6 +32,11 @@ export interface UpdateContributorInsightsCommandOutput extends UpdateContributo
|
|
|
32
32
|
* import { DynamoDBClient, UpdateContributorInsightsCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
|
|
33
33
|
* // const { DynamoDBClient, UpdateContributorInsightsCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
|
|
34
34
|
* const client = new DynamoDBClient(config);
|
|
35
|
+
* const input = {
|
|
36
|
+
* TableName: "STRING_VALUE", // required
|
|
37
|
+
* IndexName: "STRING_VALUE",
|
|
38
|
+
* ContributorInsightsAction: "ENABLE" || "DISABLE", // required
|
|
39
|
+
* };
|
|
35
40
|
* const command = new UpdateContributorInsightsCommand(input);
|
|
36
41
|
* const response = await client.send(command);
|
|
37
42
|
* ```
|
|
@@ -68,6 +68,19 @@ export interface UpdateGlobalTableCommandOutput extends UpdateGlobalTableOutput,
|
|
|
68
68
|
* import { DynamoDBClient, UpdateGlobalTableCommand } from "@aws-sdk/client-dynamodb"; // ES Modules import
|
|
69
69
|
* // const { DynamoDBClient, UpdateGlobalTableCommand } = require("@aws-sdk/client-dynamodb"); // CommonJS import
|
|
70
70
|
* const client = new DynamoDBClient(config);
|
|
71
|
+
* const input = {
|
|
72
|
+
* GlobalTableName: "STRING_VALUE", // required
|
|
73
|
+
* ReplicaUpdates: [ // required
|
|
74
|
+
* {
|
|
75
|
+
* Create: {
|
|
76
|
+
* RegionName: "STRING_VALUE", // required
|
|
77
|
+
* },
|
|
78
|
+
* Delete: {
|
|
79
|
+
* RegionName: "STRING_VALUE", // required
|
|
80
|
+
* },
|
|
81
|
+
* },
|
|
82
|
+
* ],
|
|
83
|
+
* };
|
|
71
84
|
* const command = new UpdateGlobalTableCommand(input);
|
|
72
85
|
* const response = await client.send(command);
|
|
73
86
|
* ```
|