@aws-sdk/client-dynamodb

import { SmithyException as __SmithyException } from "@aws-sdk/smithy-client"; import { MetadataBearer as $MetadataBearer } from "@aws-sdk/types"; /** * Contains details of a table archival operation. */ export interface ArchivalSummary { /** * The date and time when table archival was initiated by DynamoDB, * in UNIX epoch time format. */ ArchivalDateTime?: Date; /** * The reason DynamoDB archived the table. Currently, the only * possible value is: * * <ul> * <li> * * <code>INACCESSIBLE_ENCRYPTION_CREDENTIALS</code> - The * table was archived due to the table's AWS KMS key being inaccessible * for more than seven days. An On-Demand backup was created at the archival * time. * </li> * </ul> */ ArchivalReason?: string; /** * The Amazon Resource Name (ARN) of the backup the table was archived * to, when applicable in the archival reason. If you wish to restore this * backup to the same table name, you will need to delete the original * table. */ ArchivalBackupArn?: string; } export namespace ArchivalSummary { export const filterSensitiveLog = (obj: ArchivalSummary): any => ({ ...obj, }); } export type AttributeAction = "ADD" | "DELETE" | "PUT"; export type ScalarAttributeType = "B" | "N" | "S"; /** * Represents an attribute for describing the key schema for the table and indexes. */ export interface AttributeDefinition { /** * A name for the attribute. */ AttributeName: string | undefined; /** * The data type for the attribute, where: * <ul> * <li> * * <code>S</code> - the attribute is of type String * </li> * <li> * * <code>N</code> - the attribute is of type Number * </li> * <li> * * <code>B</code> - the attribute is of type Binary * </li> * </ul> */ AttributeType: ScalarAttributeType | string | undefined; } export namespace AttributeDefinition { export const filterSensitiveLog = (obj: AttributeDefinition): any => ({ ...obj, }); } /** * Represents the properties of a target tracking scaling policy. */ export interface AutoScalingTargetTrackingScalingPolicyConfigurationDescription { /** * Indicates whether scale in by the target tracking policy is disabled. If the value is true, * scale in is disabled and the target tracking policy won't remove capacity from the scalable resource. * Otherwise, scale in is enabled and the target tracking policy can remove capacity from the scalable resource. * The default value is false. */ DisableScaleIn?: boolean; /** * The amount of time, in seconds, after a scale in activity completes before another scale * in activity can start. The cooldown period is used to block subsequent scale in requests * until it has expired. You should scale in conservatively to protect your application's * availability. However, if another alarm triggers a scale out policy during the cooldown * period after a scale-in, application auto scaling scales out your scalable target * immediately. */ ScaleInCooldown?: number; /** * The amount of time, in seconds, after a scale out activity completes before another scale out * activity can start. While the cooldown period is in effect, the capacity that has been added * by the previous scale out event that initiated the cooldown is calculated as part of the * desired capacity for the next scale out. You should continuously (but not excessively) * scale out. */ ScaleOutCooldown?: number; /** * The target value for the metric. The range is 8.515920e-109 to 1.174271e+108 (Base 10) or 2e-360 to 2e360 (Base 2). */ TargetValue: number | undefined; } export namespace AutoScalingTargetTrackingScalingPolicyConfigurationDescription { export const filterSensitiveLog = (obj: AutoScalingTargetTrackingScalingPolicyConfigurationDescription): any => ({ ...obj, }); } /** * Represents the properties of the scaling policy. */ export interface AutoScalingPolicyDescription { /** * The name of the scaling policy. */ PolicyName?: string; /** * Represents a target tracking scaling policy configuration. */ TargetTrackingScalingPolicyConfiguration?: AutoScalingTargetTrackingScalingPolicyConfigurationDescription; } export namespace AutoScalingPolicyDescription { export const filterSensitiveLog = (obj: AutoScalingPolicyDescription): any => ({ ...obj, }); } /** * Represents the settings of a target tracking scaling policy that will be modified. */ export interface AutoScalingTargetTrackingScalingPolicyConfigurationUpdate { /** * Indicates whether scale in by the target tracking policy is disabled. If the value is true, * scale in is disabled and the target tracking policy won't remove capacity from the scalable resource. * Otherwise, scale in is enabled and the target tracking policy can remove capacity from the scalable resource. * The default value is false. */ DisableScaleIn?: boolean; /** * The amount of time, in seconds, after a scale in activity completes before another scale * in activity can start. The cooldown period is used to block subsequent scale in requests * until it has expired. You should scale in conservatively to protect your application's * availability. However, if another alarm triggers a scale out policy during the cooldown * period after a scale-in, application auto scaling scales out your scalable target * immediately. */ ScaleInCooldown?: number; /** * The amount of time, in seconds, after a scale out activity completes before another scale out * activity can start. While the cooldown period is in effect, the capacity that has been added * by the previous scale out event that initiated the cooldown is calculated as part of the * desired capacity for the next scale out. You should continuously (but not excessively) * scale out. */ ScaleOutCooldown?: number; /** * The target value for the metric. The range is 8.515920e-109 to 1.174271e+108 (Base 10) or 2e-360 to 2e360 (Base 2). */ TargetValue: number | undefined; } export namespace AutoScalingTargetTrackingScalingPolicyConfigurationUpdate { export const filterSensitiveLog = (obj: AutoScalingTargetTrackingScalingPolicyConfigurationUpdate): any => ({ ...obj, }); } /** * Represents the auto scaling policy to be modified. */ export interface AutoScalingPolicyUpdate { /** * The name of the scaling policy. */ PolicyName?: string; /** * Represents a target tracking scaling policy configuration. */ TargetTrackingScalingPolicyConfiguration: AutoScalingTargetTrackingScalingPolicyConfigurationUpdate | undefined; } export namespace AutoScalingPolicyUpdate { export const filterSensitiveLog = (obj: AutoScalingPolicyUpdate): any => ({ ...obj, }); } /** * Represents the auto scaling settings for a global table or global secondary * index. */ export interface AutoScalingSettingsDescription { /** * The minimum capacity units that a global table or global secondary index should be scaled down to. */ MinimumUnits?: number; /** * The maximum capacity units that a global table or global secondary index should be scaled up to. */ MaximumUnits?: number; /** * Disabled auto scaling for this global table or global secondary index. */ AutoScalingDisabled?: boolean; /** * Role ARN used for configuring the auto scaling policy. */ AutoScalingRoleArn?: string; /** * Information about the scaling policies. */ ScalingPolicies?: AutoScalingPolicyDescription[]; } export namespace AutoScalingSettingsDescription { export const filterSensitiveLog = (obj: AutoScalingSettingsDescription): any => ({ ...obj, }); } /** * Represents the auto scaling settings to be modified for a global table or global * secondary index. */ export interface AutoScalingSettingsUpdate { /** * The minimum capacity units that a global table or global secondary index should be scaled down to. */ MinimumUnits?: number; /** * The maximum capacity units that a global table or global secondary index should be scaled up to. */ MaximumUnits?: number; /** * Disabled auto scaling for this global table or global secondary index. */ AutoScalingDisabled?: boolean; /** * Role ARN used for configuring auto scaling policy. */ AutoScalingRoleArn?: string; /** * The scaling policy to apply for scaling target global table or global secondary index capacity units. */ ScalingPolicyUpdate?: AutoScalingPolicyUpdate; } export namespace AutoScalingSettingsUpdate { export const filterSensitiveLog = (obj: AutoScalingSettingsUpdate): any => ({ ...obj, }); } export type BackupStatus = "AVAILABLE" | "CREATING" | "DELETED"; export enum BackupType { AWS_BACKUP = "AWS_BACKUP", SYSTEM = "SYSTEM", USER = "USER", } /** * Contains the details of the backup created for the table. */ export interface BackupDetails { /** * ARN associated with the backup. */ BackupArn: string | undefined; /** * Name of the requested backup. */ BackupName: string | undefined; /** * Size of the backup in bytes. */ BackupSizeBytes?: number; /** * Backup can be in one of the following states: CREATING, ACTIVE, DELETED. */ BackupStatus: BackupStatus | string | undefined; /** * BackupType: * <ul> * <li> * * <code>USER</code> - You create and manage these using the on-demand backup feature. * </li> * <li> * * <code>SYSTEM</code> - If you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code> backup is automatically * created and is retained for 35 days (at no additional cost). System backups allow you to restore the deleted * table to the state it was in just before the point of deletion. * * </li> * <li> * * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup service. * </li> * </ul> */ BackupType: BackupType | string | undefined; /** * Time at which the backup was created. This is the request time of the backup. */ BackupCreationDateTime: Date | undefined; /** * Time at which the automatic on-demand backup created by DynamoDB will expire. This <code>SYSTEM</code> * on-demand backup expires automatically 35 days after its creation. */ BackupExpiryDateTime?: Date; } export namespace BackupDetails { export const filterSensitiveLog = (obj: BackupDetails): any => ({ ...obj, }); } export type BillingMode = "PAY_PER_REQUEST" | "PROVISIONED"; export type KeyType = "HASH" | "RANGE"; /** * Represents a single element of a key schema. A key schema specifies the attributes * that make up the primary key of a table, or the key attributes of an index. * A <code>KeySchemaElement</code> represents exactly one attribute of the primary key. For example, a * simple primary key would be represented by one <code>KeySchemaElement</code> (for the partition key). A composite * primary key would require one <code>KeySchemaElement</code> for the partition key, and another * <code>KeySchemaElement</code> for the sort key. * A <code>KeySchemaElement</code> must be a scalar, top-level attribute (not a nested attribute). The data type must be one of String, Number, or Binary. The attribute cannot be nested within a List or a Map. */ export interface KeySchemaElement { /** * The name of a key attribute. */ AttributeName: string | undefined; /** * The role that this key attribute will assume: * <ul> * <li> * * <code>HASH</code> - partition key * </li> * <li> * * <code>RANGE</code> - sort key * </li> * </ul> * <note> * The partition key of an item is also known as its hash attribute. The * term "hash attribute" derives from DynamoDB's usage of an internal hash function to * evenly distribute data items across partitions, based on their partition key values. * The sort key of an item is also known as its range attribute. * The term "range attribute" derives from the way DynamoDB stores items with the same * partition key physically close together, in sorted order by the sort key value. * </note> */ KeyType: KeyType | string | undefined; } export namespace KeySchemaElement { export const filterSensitiveLog = (obj: KeySchemaElement): any => ({ ...obj, }); } /** * Represents the provisioned throughput settings for a specified table or index. The settings * can be modified using the <code>UpdateTable</code> operation. * For current minimum and maximum provisioned throughput values, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Service, Account, and Table Quotas</a> in the Amazon DynamoDB Developer Guide. */ export interface ProvisionedThroughput { /** * The maximum number of strongly consistent reads consumed per second before DynamoDB returns a * <code>ThrottlingException</code>. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#ProvisionedThroughput">Specifying Read and Write * Requirements</a> in the Amazon DynamoDB Developer Guide. * If read/write capacity mode is <code>PAY_PER_REQUEST</code> the value is set to 0. */ ReadCapacityUnits: number | undefined; /** * The maximum number of writes consumed per second before DynamoDB returns a * <code>ThrottlingException</code>. For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#ProvisionedThroughput">Specifying Read and Write * Requirements</a> in the Amazon DynamoDB Developer Guide. * If read/write capacity mode is <code>PAY_PER_REQUEST</code> the value is set to 0. */ WriteCapacityUnits: number | undefined; } export namespace ProvisionedThroughput { export const filterSensitiveLog = (obj: ProvisionedThroughput): any => ({ ...obj, }); } /** * Contains the details of the table when the backup was created. */ export interface SourceTableDetails { /** * The name of the table for which the backup was created. */ TableName: string | undefined; /** * Unique identifier for the table for which the backup was created. */ TableId: string | undefined; /** * ARN of the table for which backup was created. */ TableArn?: string; /** * Size of the table in bytes. Note that this is an approximate value. */ TableSizeBytes?: number; /** * Schema of the table. */ KeySchema: KeySchemaElement[] | undefined; /** * Time when the source table was created. */ TableCreationDateTime: Date | undefined; /** * Read IOPs and Write IOPS on the table when the backup was created. */ ProvisionedThroughput: ProvisionedThroughput | undefined; /** * Number of items in the table. Note that this is an approximate value. */ ItemCount?: number; /** * Controls how you are charged for read and write throughput and how you manage capacity. This setting can be changed later. * <ul> * <li> * * <code>PROVISIONED</code> - Sets the read/write capacity mode to <code>PROVISIONED</code>. We recommend using <code>PROVISIONED</code> for predictable workloads. * </li> * <li> * * <code>PAY_PER_REQUEST</code> - Sets the read/write capacity mode to <code>PAY_PER_REQUEST</code>. We recommend using <code>PAY_PER_REQUEST</code> for unpredictable workloads. * * </li> * </ul> */ BillingMode?: BillingMode | string; } export namespace SourceTableDetails { export const filterSensitiveLog = (obj: SourceTableDetails): any => ({ ...obj, }); } export type ProjectionType = "ALL" | "INCLUDE" | "KEYS_ONLY"; /** * Represents attributes that are copied (projected) from the table into an index. These are in addition to the primary key attributes and index key attributes, which are automatically projected. */ export interface Projection { /** * The set of attributes that are projected into the index: * <ul> * <li> * * <code>KEYS_ONLY</code> - Only the index and primary keys are projected into the * index. * </li> * <li> * * <code>INCLUDE</code> - In addition to the attributes described in <code>KEYS_ONLY</code>, the secondary index will include other non-key attributes that you specify. * </li> * <li> * * <code>ALL</code> - All of the table attributes are projected into the index. * </li> * </ul> */ ProjectionType?: ProjectionType | string; /** * Represents the non-key attribute names which will be projected into the index. * For local secondary indexes, the total count of <code>NonKeyAttributes</code> summed across all of the local secondary indexes, * must not exceed 20. If you project the same attribute into two * different indexes, this counts as two distinct attributes when determining the total. */ NonKeyAttributes?: string[]; } export namespace Projection { export const filterSensitiveLog = (obj: Projection): any => ({ ...obj, }); } /** * Represents the properties of a global secondary index for the table * when the backup was created. */ export interface GlobalSecondaryIndexInfo { /** * The name of the global secondary index. */ IndexName?: string; /** * The complete key schema for a global secondary index, which consists of one or more pairs of attribute names and key types: * <ul> * <li> * * <code>HASH</code> - partition key * </li> * <li> * * <code>RANGE</code> - sort key * </li> * </ul> * <note> * The partition key of an item is also known as its hash attribute. The * term "hash attribute" derives from DynamoDB's usage of an internal hash function to * evenly distribute data items across partitions, based on their partition key values. * The sort key of an item is also known as its range attribute. * The term "range attribute" derives from the way DynamoDB stores items with the same * partition key physically close together, in sorted order by the sort key value. * </note> */ KeySchema?: KeySchemaElement[]; /** * Represents attributes that are copied (projected) from the table into * the global secondary index. These are in addition to the primary * key attributes and index key attributes, which are automatically * projected. */ Projection?: Projection; /** * Represents the provisioned throughput settings for the specified global secondary index. */ ProvisionedThroughput?: ProvisionedThroughput; } export namespace GlobalSecondaryIndexInfo { export const filterSensitiveLog = (obj: GlobalSecondaryIndexInfo): any => ({ ...obj, }); } /** * Represents the properties of a local secondary index for the table * when the backup was created. */ export interface LocalSecondaryIndexInfo { /** * Represents the name of the local secondary index. */ IndexName?: string; /** * The complete key schema for a local secondary index, which consists of one or more pairs of attribute names and key types: * <ul> * <li> * * <code>HASH</code> - partition key * </li> * <li> * * <code>RANGE</code> - sort key * </li> * </ul> * <note> * The partition key of an item is also known as its hash attribute. The * term "hash attribute" derives from DynamoDB's usage of an internal hash function to * evenly distribute data items across partitions, based on their partition key values. * The sort key of an item is also known as its range attribute. * The term "range attribute" derives from the way DynamoDB stores items with the same * partition key physically close together, in sorted order by the sort key value. * </note> */ KeySchema?: KeySchemaElement[]; /** * Represents attributes that are copied (projected) from the table into the global secondary index. These are in addition to the primary key attributes and index key attributes, which are automatically projected. */ Projection?: Projection; } export namespace LocalSecondaryIndexInfo { export const filterSensitiveLog = (obj: LocalSecondaryIndexInfo): any => ({ ...obj, }); } export type SSEType = "AES256" | "KMS"; export type SSEStatus = "DISABLED" | "DISABLING" | "ENABLED" | "ENABLING" | "UPDATING"; /** * The description of the server-side encryption status on the specified table. */ export interface SSEDescription { /** * Represents the current state of server-side encryption. The only supported values are: * <ul> * <li> * * <code>ENABLED</code> - Server-side encryption is enabled. * </li> * <li> * * <code>UPDATING</code> - Server-side encryption is being updated. * </li> * </ul> */ Status?: SSEStatus | string; /** * Server-side encryption type. The only supported value is: * <ul> * <li> * * <code>KMS</code> - Server-side encryption that uses AWS Key Management Service. The * key is stored in your account and is managed by AWS KMS (AWS KMS charges * apply). * </li> * </ul> */ SSEType?: SSEType | string; /** * The AWS KMS customer master key (CMK) ARN used for the AWS KMS encryption. */ KMSMasterKeyArn?: string; /** * Indicates the time, in UNIX epoch date format, when DynamoDB detected that the table's * AWS KMS key was inaccessible. This attribute will automatically be cleared when DynamoDB * detects that the table's AWS KMS key is accessible again. DynamoDB will initiate the table * archival process when table's AWS KMS key remains inaccessible for more than seven days * from this date. */ InaccessibleEncryptionDateTime?: Date; } export namespace SSEDescription { export const filterSensitiveLog = (obj: SSEDescription): any => ({ ...obj, }); } export type StreamViewType = "KEYS_ONLY" | "NEW_AND_OLD_IMAGES" | "NEW_IMAGE" | "OLD_IMAGE"; /** * Represents the DynamoDB Streams configuration for a table in DynamoDB. */ export interface StreamSpecification { /** * Indicates whether DynamoDB Streams is enabled (true) or disabled (false) on the table. */ StreamEnabled: boolean | undefined; /** * * When an item in the table is modified, <code>StreamViewType</code> * determines what information is written to the stream for this table. Valid values for * <code>StreamViewType</code> are: * <ul> * <li> * * <code>KEYS_ONLY</code> - Only the key attributes of the modified item are written to the stream. * </li> * <li> * * <code>NEW_IMAGE</code> - The entire item, as it appears after it was modified, is written * to the stream. * </li> * <li> * * <code>OLD_IMAGE</code> - The entire item, as it appeared before it was modified, is * written to the stream. * </li> * <li> * * <code>NEW_AND_OLD_IMAGES</code> - Both the new and the old item images of the item are * written to the stream. * </li> * </ul> */ StreamViewType?: StreamViewType | string; } export namespace StreamSpecification { export const filterSensitiveLog = (obj: StreamSpecification): any => ({ ...obj, }); } export type TimeToLiveStatus = "DISABLED" | "DISABLING" | "ENABLED" | "ENABLING"; /** * The description of the Time to Live (TTL) status on the specified table. */ export interface TimeToLiveDescription { /** * The TTL status for the table. */ TimeToLiveStatus?: TimeToLiveStatus | string; /** * The name of the TTL attribute for items in the table. */ AttributeName?: string; } export namespace TimeToLiveDescription { export const filterSensitiveLog = (obj: TimeToLiveDescription): any => ({ ...obj, }); } /** * Contains the details of the features enabled on the table when the backup was created. For example, LSIs, GSIs, streams, TTL. */ export interface SourceTableFeatureDetails { /** * Represents the LSI properties for the table when the backup was created. It includes the IndexName, KeySchema and Projection for the LSIs on the table at the time of backup. */ LocalSecondaryIndexes?: LocalSecondaryIndexInfo[]; /** * Represents the GSI properties for the table when the backup was created. It includes the * IndexName, KeySchema, Projection, and ProvisionedThroughput for the GSIs on the table at * the time of backup. */ GlobalSecondaryIndexes?: GlobalSecondaryIndexInfo[]; /** * Stream settings on the table when the backup was created. */ StreamDescription?: StreamSpecification; /** * Time to Live settings on the table when the backup was created. */ TimeToLiveDescription?: TimeToLiveDescription; /** * The description of the server-side encryption status on the table when the backup was created. */ SSEDescription?: SSEDescription; } export namespace SourceTableFeatureDetails { export const filterSensitiveLog = (obj: SourceTableFeatureDetails): any => ({ ...obj, }); } /** * Contains the description of the backup created for the table. */ export interface BackupDescription { /** * Contains the details of the backup created for the table. */ BackupDetails?: BackupDetails; /** * Contains the details of the table when the backup was created. */ SourceTableDetails?: SourceTableDetails; /** * Contains the details of the features enabled on the table when the backup was created. For example, LSIs, GSIs, streams, TTL. */ SourceTableFeatureDetails?: SourceTableFeatureDetails; } export namespace BackupDescription { export const filterSensitiveLog = (obj: BackupDescription): any => ({ ...obj, }); } /** * There is another ongoing conflicting backup control plane operation on the table. The backup is either being created, deleted or restored to a table. */ export interface BackupInUseException extends __SmithyException, $MetadataBearer { name: "BackupInUseException"; $fault: "client"; message?: string; } export namespace BackupInUseException { export const filterSensitiveLog = (obj: BackupInUseException): any => ({ ...obj, }); } /** * Backup not found for the given BackupARN. */ export interface BackupNotFoundException extends __SmithyException, $MetadataBearer { name: "BackupNotFoundException"; $fault: "client"; message?: string; } export namespace BackupNotFoundException { export const filterSensitiveLog = (obj: BackupNotFoundException): any => ({ ...obj, }); } /** * Contains details for the backup. */ export interface BackupSummary { /** * Name of the table. */ TableName?: string; /** * Unique identifier for the table. */ TableId?: string; /** * ARN associated with the table. */ TableArn?: string; /** * ARN associated with the backup. */ BackupArn?: string; /** * Name of the specified backup. */ BackupName?: string; /** * Time at which the backup was created. */ BackupCreationDateTime?: Date; /** * Time at which the automatic on-demand backup created by DynamoDB will expire. This * <code>SYSTEM</code> on-demand backup expires automatically 35 days after its * creation. */ BackupExpiryDateTime?: Date; /** * Backup can be in one of the following states: CREATING, ACTIVE, DELETED. */ BackupStatus?: BackupStatus | string; /** * BackupType: * <ul> * <li> * * <code>USER</code> - You create and manage these using the on-demand backup feature. * </li> * <li> * * <code>SYSTEM</code> - If you delete a table with point-in-time recovery enabled, a <code>SYSTEM</code> backup is automatically * created and is retained for 35 days (at no additional cost). System backups allow you to restore the deleted * table to the state it was in just before the point of deletion. * * </li> * <li> * * <code>AWS_BACKUP</code> - On-demand backup created by you from AWS Backup service. * </li> * </ul> */ BackupType?: BackupType | string; /** * Size of the backup in bytes. */ BackupSizeBytes?: number; } export namespace BackupSummary { export const filterSensitiveLog = (obj: BackupSummary): any => ({ ...obj, }); } export enum BackupTypeFilter { ALL = "ALL", AWS_BACKUP = "AWS_BACKUP", SYSTEM = "SYSTEM", USER = "USER", } export enum BatchStatementErrorCodeEnum { AccessDenied = "AccessDenied", ConditionalCheckFailed = "ConditionalCheckFailed", DuplicateItem = "DuplicateItem", InternalServerError = "InternalServerError", ItemCollectionSizeLimitExceeded = "ItemCollectionSizeLimitExceeded", ProvisionedThroughputExceeded = "ProvisionedThroughputExceeded", RequestLimitExceeded = "RequestLimitExceeded", ResourceNotFound = "ResourceNotFound", ThrottlingError = "ThrottlingError", TransactionConflict = "TransactionConflict", ValidationError = "ValidationError", } /** * * An error associated with a statement in a PartiQL batch that was run. * */ export interface BatchStatementError { /** * * The error code associated with the failed PartiQL batch statement. * */ Code?: BatchStatementErrorCodeEnum | string; /** * * The error message associated with the PartiQL batch resposne. * */ Message?: string; } export namespace BatchStatementError { export const filterSensitiveLog = (obj: BatchStatementError): any => ({ ...obj, }); } /** * An error occurred on the server side. */ export interface InternalServerError extends __SmithyException, $MetadataBearer { name: "InternalServerError"; $fault: "server"; /** * The server encountered an internal error trying to fulfill the request. */ message?: string; } export namespace InternalServerError { export const filterSensitiveLog = (obj: InternalServerError): any => ({ ...obj, }); } /** * Throughput exceeds the current throughput quota for your account. Please contact AWS Support at <a href="https://aws.amazon.com/support">AWS Support</a> to request a quota increase. */ export interface RequestLimitExceeded extends __SmithyException, $MetadataBearer { name: "RequestLimitExceeded"; $fault: "client"; message?: string; } export namespace RequestLimitExceeded { export const filterSensitiveLog = (obj: RequestLimitExceeded): any => ({ ...obj, }); } export type ReturnConsumedCapacity = "INDEXES" | "NONE" | "TOTAL"; /** * Represents the amount of provisioned throughput capacity consumed on a table or an index. */ export interface Capacity { /** * The total number of read capacity units consumed on a table or an index. */ ReadCapacityUnits?: number; /** * The total number of write capacity units consumed on a table or an index. */ WriteCapacityUnits?: number; /** * The total number of capacity units consumed on a table or an index. */ CapacityUnits?: number; } export namespace Capacity { export const filterSensitiveLog = (obj: Capacity): any => ({ ...obj, }); } /** * The capacity units consumed by an operation. The data returned includes the total * provisioned throughput consumed, along with statistics for the table and any indexes involved * in the operation. <code>ConsumedCapacity</code> is only returned if the request asked for it. * For more information, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html">Provisioned * Throughput</a> in the Amazon DynamoDB Developer Guide. */ export interface ConsumedCapacity { /** * The name of the table that was affected by the operation. */ TableName?: string; /** * The total number of capacity units consumed by the operation. */ CapacityUnits?: number; /** * The total number of read capacity units consumed by the operation. */ ReadCapacityUnits?: number; /** * The total number of write capacity units consumed by the operation. */ WriteCapacityUnits?: number; /** * The amount of throughput consumed on the table affected by the operation. */ Table?: Capacity; /** * The amount of throughput consumed on each local index affected by the operation. */ LocalSecondaryIndexes?: { [key: string]: Capacity }; /** * The amount of throughput consumed on each global index affected by the operation. */ GlobalSecondaryIndexes?: { [key: string]: Capacity }; } export namespace ConsumedCapacity { export const filterSensitiveLog = (obj: ConsumedCapacity): any => ({ ...obj, }); } export interface InvalidEndpointException extends __SmithyException, $MetadataBearer { name: "InvalidEndpointException"; $fault: "client"; Message?: string; } export namespace InvalidEndpointException { export const filterSensitiveLog = (obj: InvalidEndpointException): any => ({ ...obj, }); } /** * Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests that * receive this exception. Your request is eventually successful, unless your retry queue is too * large to finish. Reduce the frequency of requests and use exponential backoff. For more * information, go to <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.Errors.html#Programming.Errors.RetryAndBackoff">Error Retries and Exponential * Backoff</a> in the Amazon DynamoDB Developer Guide. */ export interface ProvisionedThroughputExceededException extends __SmithyException, $MetadataBearer { name: "ProvisionedThroughputExceededException"; $fault: "client"; /** * You exceeded your maximum allowed provisioned throughput. */ message?: string; } export namespace ProvisionedThroughputExceededException { export const filterSensitiveLog = (obj: ProvisionedThroughputExceededException): any => ({ ...obj, }); } /** * 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>. */ export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer { name: "ResourceNotFoundException"; $fault: "client"; /** * The resource which is being requested does not exist. */ message?: string; } export namespace ResourceNotFoundException { export const filterSensitiveLog = (obj: ResourceNotFoundException): any => ({ ...obj, }); } export type ReturnItemCollectionMetrics = "NONE" | "SIZE"; /** * An item collection is too large. This exception is only returned for tables that have one or more local secondary indexes. */ export interface ItemCollectionSizeLimitExceededException extends __SmithyException, $MetadataBearer { name: "ItemCollectionSizeLimitExceededException"; $fault: "client"; /** * The total size of an item collection has exceeded the maximum limit of 10 gigabytes. */ message?: string; } export namespace ItemCollectionSizeLimitExceededException { export const filterSensitiveLog = (obj: ItemCollectionSizeLimitExceededException): any => ({ ...obj, }); } /** * Contains the details for the read/write capacity mode. */ export interface BillingModeSummary { /** * Controls how you are charged for read and write throughput and how you manage capacity. This setting can be changed later. * <ul> * <li> * * <code>PROVISIONED</code> - Sets the read/write capacity mode to <code>PROVISIONED</code>. We recommend using <code>PROVISIONED</code> for predictable workloads. * </li> * <li> * * <code>PAY_PER_REQUEST</code> - Sets the read/write capacity mode to <code>PAY_PER_REQUEST</code>. We recommend using <code>PAY_PER_REQUEST</code> for unpredictable workloads. * * </li> * </ul> */ BillingMode?: BillingMode | string; /** * Represents the time when <code>PAY_PER_REQUEST</code> was last set as the read/write capacity mode. */ LastUpdateToPayPerRequestDateTime?: Date; } export namespace BillingModeSummary { export const filterSensitiveLog = (obj: BillingModeSummary): any => ({ ...obj, }); } export type ComparisonOperator = | "BEGINS_WITH" | "BETWEEN" | "CONTAINS" | "EQ" | "GE" | "GT" | "IN" | "LE" | "LT" | "NE" | "NOT_CONTAINS" | "NOT_NULL" | "NULL"; /** * A condition specified in the operation could not be evaluated. */ export interface ConditionalCheckFailedException extends __SmithyException, $MetadataBearer { name: "ConditionalCheckFailedException"; $fault: "client"; /** * The conditional request failed. */ message?: string; } export namespace ConditionalCheckFailedException { export const filterSensitiveLog = (obj: ConditionalCheckFailedException): any => ({ ...obj, }); } export type ConditionalOperator = "AND" | "OR"; export type ReturnValuesOnConditionCheckFailure = "ALL_OLD" | "NONE"; export type ContinuousBackupsStatus = "DISABLED" | "ENABLED"; export type PointInTimeRecoveryStatus = "DISABLED" | "ENABLED"; /** * The description of the point in time settings applied to the table. */ export interface PointInTimeRecoveryDescription { /** * The current state of point in time recovery: * <ul> * <li> * * <code>ENABLING</code> - Point in time recovery is being enabled. * </li> * <li> * * <code>ENABLED</code> - Point in time recovery is enabled. * </li> * <li> * * <code>DISABLED</code> - Point in time recovery is disabled. * </li> * </ul> */ PointInTimeRecoveryStatus?: PointInTimeRecoveryStatus | string; /** * Specifies the earliest point in time you can restore your table to. You can restore your * table to any point in time during the last 35 days. */ EarliestRestorableDateTime?: Date; /** * * <code>LatestRestorableDateTime</code> is typically 5 minutes before the current time. * */ LatestRestorableDateTime?: Date; } export namespace PointInTimeRecoveryDescription { export const filterSensitiveLog = (obj: PointInTimeRecoveryDescription): any => ({ ...obj, }); } /** * Represents the continuous backups and point in time recovery settings on the table. */ export interface ContinuousBackupsDescription { /** * * <code>ContinuousBackupsStatus</code> can be one of the following states: ENABLED, * DISABLED */ ContinuousBackupsStatus: ContinuousBackupsStatus | string | undefined; /** * The description of the point in time recovery settings applied to the table. */ PointInTimeRecoveryDescription?: PointInTimeRecoveryDescription; } export namespace ContinuousBackupsDescription { export const filterSensitiveLog = (obj: ContinuousBackupsDescription): any => ({ ...obj, }); } /** * Backups have not yet been enabled for this table. */ export interface ContinuousBackupsUnavailableException extends __SmithyException, $MetadataBearer { name: "ContinuousBackupsUnavailableException"; $fault: "client"; message?: string; } export namespace ContinuousBackupsUnavailableException { export const filterSensitiveLog = (obj: ContinuousBackupsUnavailableException): any => ({ ...obj, }); } export type ContributorInsightsAction = "DISABLE" | "ENABLE"; export type ContributorInsightsStatus = "DISABLED" | "DISABLING" | "ENABLED" | "ENABLING" | "FAILED"; /** * Represents a Contributor Insights summary entry. */ export interface ContributorInsightsSummary { /** * Name of the table associated with the summary. */ TableName?: string; /** * Name of the index associated with the summary, if any. */ IndexName?: string; /** * Describes the current status for contributor insights for the given table and index, if applicable. */ ContributorInsightsStatus?: ContributorInsightsStatus | string; } export namespace ContributorInsightsSummary { export const filterSensitiveLog = (obj: ContributorInsightsSummary): any => ({ ...obj, }); } export interface CreateBackupInput { /** * The name of the table. */ TableName: string | undefined; /** * Specified name for the backup. */ BackupName: string | undefined; } export namespace CreateBackupInput { export const filterSensitiveLog = (obj: CreateBackupInput): any => ({ ...obj, }); } export interface CreateBackupOutput { /** * Contains the details of the backup created for the table. */ BackupDetails?: BackupDetails; } export namespace CreateBackupOutput { export const filterSensitiveLog = (obj: CreateBackupOutput): any => ({ ...obj, }); } /** * There is no limit to the number of daily on-demand backups that can be taken. * Up to 50 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>. * The only exception is when you are creating a table with one or more secondary indexes. You can have up to * 25 such requests running at a time; however, if the table or index specifications are complex, DynamoDB might temporarily * reduce the number of concurrent operations. * There is a soft account quota of 256 tables. */ export interface LimitExceededException extends __SmithyException, $MetadataBearer { name: "LimitExceededException"; $fault: "client"; /** * Too many operations for a given subscriber. */ message?: string; } export namespace LimitExceededException { export const filterSensitiveLog = (obj: LimitExceededException): any => ({ ...obj, }); } /** * A target table with the specified name is either being created or deleted. */ export interface TableInUseException extends __SmithyException, $MetadataBearer { name: "TableInUseException"; $fault: "client"; message?: string; } export namespace TableInUseException { export const filterSensitiveLog = (obj: TableInUseException): any => ({ ...obj, }); } /** * A source table with the name <code>TableName</code> does not currently exist within the subscriber's account. */ export interface TableNotFoundException extends __SmithyException, $MetadataBearer { name: "TableNotFoundException"; $fault: "client"; message?: string; } export namespace TableNotFoundException { export const filterSensitiveLog = (obj: TableNotFoundException): any => ({ ...obj, }); } /** * Represents a new global secondary index to be added to an existing table. */ export interface CreateGlobalSecondaryIndexAction { /** * The name of the global secondary index to be created. */ IndexName: string | undefined; /** * The key schema for the global secondary index. */ KeySchema: KeySchemaElement[] | undefined; /** * Represents attributes that are copied (projected) from the table into an index. These * are in addition to the primary key attributes and index key attributes, which are * automatically projected. */ Projection: Projection | undefined; /** * Represents the provisioned throughput settings for the specified global secondary index. * For current minimum and maximum provisioned throughput values, see <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Service, Account, and Table Quotas</a> in the Amazon DynamoDB Developer Guide. */ ProvisionedThroughput?: ProvisionedThroughput; } export namespace CreateGlobalSecondaryIndexAction { export const filterSensitiveLog = (obj: CreateGlobalSecondaryIndexAction): any => ({ ...obj, }); } /** * Represents the properties of a replica. */ export interface Replica { /** * The Region where the replica needs to be created. */ RegionName?: string; } export namespace Replica { export const filterSensitiveLog = (obj: Replica): any => ({ ...obj, }); } export interface CreateGlobalTableInput { /** * The global table name. */ GlobalTableName: string | undefined; /** * The Regions where the global table needs to be created. */ ReplicationGroup: Replica[] | undefined; } export namespace CreateGlobalTableInput { export const filterSensitiveLog = (obj: CreateGlobalTableInput): any => ({ ...obj, }); } export type GlobalTableStatus = "ACTIVE" | "CREATING" | "DELETING" | "UPDATING"; /** * Replica-specific provisioned throughput settings. If not specified, uses the * source table's provisioned throughput settings. */ export interface ProvisionedThroughputOverride { /** * Replica-specific read capacity units. If not specified, uses the source table's * read capacity settings. */ ReadCapacityUnits?: number; } export namespace ProvisionedThroughputOverride { export const filterSensitiveLog = (obj: ProvisionedThroughputOverride): any => ({ ...obj, }); } /** * Represents the properties of a replica global secondary index. */ export interface ReplicaGlobalSecondaryIndexDescription { /** * The name of the global secondary index. */ IndexName?: string; /**