@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 declare namespace ArchivalSummary { const filterSensitiveLog: (obj: ArchivalSummary) => any; } export declare type AttributeAction = "ADD" | "DELETE" | "PUT"; export declare 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 declare namespace AttributeDefinition { const filterSensitiveLog: (obj: AttributeDefinition) => any; } /** * 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 declare namespace AutoScalingTargetTrackingScalingPolicyConfigurationDescription { const filterSensitiveLog: (obj: AutoScalingTargetTrackingScalingPolicyConfigurationDescription) => any; } /** * 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 declare namespace AutoScalingPolicyDescription { const filterSensitiveLog: (obj: AutoScalingPolicyDescription) => any; } /** * 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 declare namespace AutoScalingTargetTrackingScalingPolicyConfigurationUpdate { const filterSensitiveLog: (obj: AutoScalingTargetTrackingScalingPolicyConfigurationUpdate) => any; } /** * 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 declare namespace AutoScalingPolicyUpdate { const filterSensitiveLog: (obj: AutoScalingPolicyUpdate) => any; } /** * 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 declare namespace AutoScalingSettingsDescription { const filterSensitiveLog: (obj: AutoScalingSettingsDescription) => any; } /** * 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 declare namespace AutoScalingSettingsUpdate { const filterSensitiveLog: (obj: AutoScalingSettingsUpdate) => any; } export declare type BackupStatus = "AVAILABLE" | "CREATING" | "DELETED"; export declare 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 declare namespace BackupDetails { const filterSensitiveLog: (obj: BackupDetails) => any; } export declare type BillingMode = "PAY_PER_REQUEST" | "PROVISIONED"; export declare 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 declare namespace KeySchemaElement { const filterSensitiveLog: (obj: KeySchemaElement) => any; } /** * 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 declare namespace ProvisionedThroughput { const filterSensitiveLog: (obj: ProvisionedThroughput) => any; } /** * 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 declare namespace SourceTableDetails { const filterSensitiveLog: (obj: SourceTableDetails) => any; } export declare 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 declare namespace Projection { const filterSensitiveLog: (obj: Projection) => any; } /** * 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 declare namespace GlobalSecondaryIndexInfo { const filterSensitiveLog: (obj: GlobalSecondaryIndexInfo) => any; } /** * 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 declare namespace LocalSecondaryIndexInfo { const filterSensitiveLog: (obj: LocalSecondaryIndexInfo) => any; } export declare type SSEType = "AES256" | "KMS"; export declare 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 declare namespace SSEDescription { const filterSensitiveLog: (obj: SSEDescription) => any; } export declare 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 declare namespace StreamSpecification { const filterSensitiveLog: (obj: StreamSpecification) => any; } export declare 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 declare namespace TimeToLiveDescription { const filterSensitiveLog: (obj: TimeToLiveDescription) => any; } /** * 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 declare namespace SourceTableFeatureDetails { const filterSensitiveLog: (obj: SourceTableFeatureDetails) => any; } /** * 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 declare namespace BackupDescription { const filterSensitiveLog: (obj: BackupDescription) => any; } /** * 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 declare namespace BackupInUseException { const filterSensitiveLog: (obj: BackupInUseException) => any; } /** * Backup not found for the given BackupARN. */ export interface BackupNotFoundException extends __SmithyException, $MetadataBearer { name: "BackupNotFoundException"; $fault: "client"; message?: string; } export declare namespace BackupNotFoundException { const filterSensitiveLog: (obj: BackupNotFoundException) => any; } /** * 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 declare namespace BackupSummary { const filterSensitiveLog: (obj: BackupSummary) => any; } export declare enum BackupTypeFilter { ALL = "ALL", AWS_BACKUP = "AWS_BACKUP", SYSTEM = "SYSTEM", USER = "USER" } export declare 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 declare namespace BatchStatementError { const filterSensitiveLog: (obj: BatchStatementError) => any; } /** * 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 declare namespace InternalServerError { const filterSensitiveLog: (obj: InternalServerError) => any; } /** * 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 declare namespace RequestLimitExceeded { const filterSensitiveLog: (obj: RequestLimitExceeded) => any; } export declare 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 declare namespace Capacity { const filterSensitiveLog: (obj: Capacity) => any; } /** * 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 declare namespace ConsumedCapacity { const filterSensitiveLog: (obj: ConsumedCapacity) => any; } export interface InvalidEndpointException extends __SmithyException, $MetadataBearer { name: "InvalidEndpointException"; $fault: "client"; Message?: string; } export declare namespace InvalidEndpointException { const filterSensitiveLog: (obj: InvalidEndpointException) => any; } /** * 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 declare namespace ProvisionedThroughputExceededException { const filterSensitiveLog: (obj: ProvisionedThroughputExceededException) => any; } /** * 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 declare namespace ResourceNotFoundException { const filterSensitiveLog: (obj: ResourceNotFoundException) => any; } export declare 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 declare namespace ItemCollectionSizeLimitExceededException { const filterSensitiveLog: (obj: ItemCollectionSizeLimitExceededException) => any; } /** * 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 declare namespace BillingModeSummary { const filterSensitiveLog: (obj: BillingModeSummary) => any; } export declare 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 declare namespace ConditionalCheckFailedException { const filterSensitiveLog: (obj: ConditionalCheckFailedException) => any; } export declare type ConditionalOperator = "AND" | "OR"; export declare type ReturnValuesOnConditionCheckFailure = "ALL_OLD" | "NONE"; export declare type ContinuousBackupsStatus = "DISABLED" | "ENABLED"; export declare 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 declare namespace PointInTimeRecoveryDescription { const filterSensitiveLog: (obj: PointInTimeRecoveryDescription) => any; } /** * 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 declare namespace ContinuousBackupsDescription { const filterSensitiveLog: (obj: ContinuousBackupsDescription) => any; } /** * Backups have not yet been enabled for this table. */ export interface ContinuousBackupsUnavailableException extends __SmithyException, $MetadataBearer { name: "ContinuousBackupsUnavailableException"; $fault: "client"; message?: string; } export declare namespace ContinuousBackupsUnavailableException { const filterSensitiveLog: (obj: ContinuousBackupsUnavailableException) => any; } export declare type ContributorInsightsAction = "DISABLE" | "ENABLE"; export declare 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 declare namespace ContributorInsightsSummary { const filterSensitiveLog: (obj: ContributorInsightsSummary) => any; } export interface CreateBackupInput { /** * The name of the table. */ TableName: string | undefined; /** * Specified name for the backup. */ BackupName: string | undefined; } export declare namespace CreateBackupInput { const filterSensitiveLog: (obj: CreateBackupInput) => any; } export interface CreateBackupOutput { /** * Contains the details of the backup created for the table. */ BackupDetails?: BackupDetails; } export declare namespace CreateBackupOutput { const filterSensitiveLog: (obj: CreateBackupOutput) => any; } /** * 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 declare namespace LimitExceededException { const filterSensitiveLog: (obj: LimitExceededException) => any; } /** * 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 declare namespace TableInUseException { const filterSensitiveLog: (obj: TableInUseException) => any; } /** * 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 declare namespace TableNotFoundException { const filterSensitiveLog: (obj: TableNotFoundException) => any; } /** * 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 declare namespace CreateGlobalSecondaryIndexAction { const filterSensitiveLog: (obj: CreateGlobalSecondaryIndexAction) => any; } /** * Represents the properties of a replica. */ export interface Replica { /** * The Region where the replica needs to be created. */ RegionName?: string; } export declare namespace Replica { const filterSensitiveLog: (obj: Replica) => any; } export interface CreateGlobalTableInput { /** * The global table name. */ GlobalTableName: string | undefined; /** * The Regions where the global table needs to be created. */ ReplicationGroup: Replica[] | undefined; } export declare namespace CreateGlobalTableInput { const filterSensitiveLog: (obj: CreateGlobalTableInput) => any; } export declare type GlobalTableStatus = "ACTIVE" | "CREATING" | "DELETING" | "UPDATING"; /** * Replica-specific provisioned throughput settings. I