dynamodb

type BatchGetItemInput struct {
	// A map of one or more table names and, for each table, a map that describes one
	// or more items to retrieve from that table. Each table name can be used only once
	// per BatchGetItem request. Each element in the map of items to retrieve consists
	// of the following:
	//
	//     * ConsistentRead - If true, a strongly consistent read is
	// used; if false (the default), an eventually consistent read is used.
	//
	//     *
	// ExpressionAttributeNames - One or more substitution tokens for attribute names
	// in the ProjectionExpression parameter. The following are some use cases for
	// using ExpressionAttributeNames:
	//
	//         * To access an attribute whose name
	// conflicts with a DynamoDB reserved word.
	//
	//         * To create a placeholder for
	// repeating occurrences of an attribute name in an expression.
	//
	//         * To
	// prevent special characters in an attribute name from being misinterpreted in an
	// expression.
	//
	//     Use the # character in an expression to dereference an
	// attribute name. For example, consider the following attribute name:
	//
	//         *
	// Percentile
	//
	//     The name of this attribute conflicts with a reserved word, so it
	// cannot be used directly in an expression. (For the complete list of reserved
	// words, see Reserved Words
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html)
	// in the Amazon DynamoDB Developer Guide). To work around this, you could specify
	// the following for ExpressionAttributeNames:
	//
	//         * {"#P":"Percentile"}
	//
	//
	// You could then use this substitution in an expression, as in this example:
	//
	//
	// * #P = :val
	//
	//     Tokens that begin with the : character are expression attribute
	// values, which are placeholders for the actual value at runtime. For more
	// information about expression attribute names, see Accessing Item Attributes
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html)
	// in the Amazon DynamoDB Developer Guide.
	//
	//     * Keys - An array of primary key
	// attribute values that define specific items in the table. For each primary key,
	// you must provide all of the key attributes. For example, with a simple primary
	// key, you only need to provide the partition key value. For a composite key, you
	// must provide both the partition key value and the sort key value.
	//
	//     *
	// ProjectionExpression - A string that identifies one or more attributes to
	// retrieve from the table. These attributes can include scalars, sets, or elements
	// of a JSON document. The attributes in the expression must be separated by
	// commas. If no attribute names are specified, then all attributes are returned.
	// If any of the requested attributes are not found, they do not appear in the
	// result. For more information, see Accessing Item Attributes
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html)
	// in the Amazon DynamoDB Developer Guide.
	//
	//     * AttributesToGet - This is a
	// legacy parameter. Use ProjectionExpression instead. For more information, see
	// AttributesToGet
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html)
	// in the Amazon DynamoDB Developer Guide.  </p> </li> </ul>
	RequestItems map[string]*types.KeysAndAttributes
	// Determines the level of detail about provisioned throughput consumption that is
	// returned in the response:
	//
	//     * INDEXES - The response includes the aggregate
	// ConsumedCapacity for the operation, together with ConsumedCapacity for each
	// table and secondary index that was accessed. Note that some operations, such as
	// GetItem and BatchGetItem, do not access any indexes at all. In these cases,
	// specifying INDEXES will only return ConsumedCapacity information for table(s).
	//
	//
	// * TOTAL - The response includes only the aggregate ConsumedCapacity for the
	// operation.
	//
	//     * NONE - No ConsumedCapacity details are included in the
	// response.
	ReturnConsumedCapacity types.ReturnConsumedCapacity
}

type BatchGetItemOutput struct {
	// A map of table name to a list of items. Each object in Responses consists of a
	// table name, along with a map of attribute data consisting of the data type and
	// attribute value.
	Responses map[string][]map[string]*types.AttributeValue
	// The read capacity units consumed by the entire BatchGetItem operation. Each
	// element consists of:
	//
	//     * TableName - The table that consumed the provisioned
	// throughput.
	//
	//     * CapacityUnits - The total number of capacity units consumed.
	ConsumedCapacity []*types.ConsumedCapacity
	// A map of tables and their respective keys that were not processed with the
	// current response. The UnprocessedKeys value is in the same form as RequestItems,
	// so the value can be provided directly to a subsequent BatchGetItem operation.
	// For more information, see RequestItems in the Request Parameters section. Each
	// element consists of:
	//
	//     * Keys - An array of primary key attribute values that
	// define specific items in the table.
	//
	//     * ProjectionExpression - One or more
	// attributes to be retrieved from the table or index. By default, all attributes
	// are returned. If a requested attribute is not found, it does not appear in the
	// result.
	//
	//     * ConsistentRead - The consistency of a read operation. If set to
	// true, then a strongly consistent read is used; otherwise, an eventually
	// consistent read is used.
	//
	// If there are no unprocessed keys remaining, the
	// response contains an empty UnprocessedKeys map.
	UnprocessedKeys map[string]*types.KeysAndAttributes

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchWriteItemInput struct {
	// Determines the level of detail about provisioned throughput consumption that is
	// returned in the response:
	//
	//     * INDEXES - The response includes the aggregate
	// ConsumedCapacity for the operation, together with ConsumedCapacity for each
	// table and secondary index that was accessed. Note that some operations, such as
	// GetItem and BatchGetItem, do not access any indexes at all. In these cases,
	// specifying INDEXES will only return ConsumedCapacity information for table(s).
	//
	//
	// * TOTAL - The response includes only the aggregate ConsumedCapacity for the
	// operation.
	//
	//     * NONE - No ConsumedCapacity details are included in the
	// response.
	ReturnConsumedCapacity types.ReturnConsumedCapacity
	// A map of one or more table names and, for each table, a list of operations to be
	// performed (DeleteRequest or PutRequest). Each element in the map consists of the
	// following:
	//
	//     * DeleteRequest - Perform a DeleteItem operation on the
	// specified item. The item to be deleted is identified by a Key subelement:
	//
	//
	// * Key - A map of primary key attribute values that uniquely identify the item.
	// Each entry in this map consists of an attribute name and an attribute value. For
	// each primary key, you must provide all of the key attributes. For example, with
	// a simple primary key, you only need to provide a value for the partition key.
	// For a composite primary key, you must provide values for both the partition key
	// and the sort key.
	//
	//     * PutRequest - Perform a PutItem operation on the
	// specified item. The item to be put is identified by an Item subelement:
	//
	//
	// * Item - A map of attributes and their values. Each entry in this map consists
	// of an attribute name and an attribute value. Attribute values must not be null;
	// string and binary type attributes must have lengths greater than zero; and set
	// type attributes must not be empty. Requests that contain empty values are
	// rejected with a ValidationException exception. If you specify any attributes
	// that are part of an index key, then the data types for those attributes must
	// match those of the schema in the table's attribute definition.
	RequestItems map[string][]*types.WriteRequest
	// Determines whether item collection metrics are returned. If set to SIZE, the
	// response includes statistics about item collections, if any, that were modified
	// during the operation are returned in the response. If set to NONE (the default),
	// no statistics are returned.
	ReturnItemCollectionMetrics types.ReturnItemCollectionMetrics
}

type BatchWriteItemOutput struct {
	// A map of tables and requests against those tables that were not processed. The
	// UnprocessedItems value is in the same form as RequestItems, so you can provide
	// this value directly to a subsequent BatchGetItem operation. For more
	// information, see RequestItems in the Request Parameters section. Each
	// UnprocessedItems entry consists of a table name and, for that table, a list of
	// operations to perform (DeleteRequest or PutRequest).
	//
	//     * DeleteRequest -
	// Perform a DeleteItem operation on the specified item. The item to be deleted is
	// identified by a Key subelement:
	//
	//         * Key - A map of primary key attribute
	// values that uniquely identify the item. Each entry in this map consists of an
	// attribute name and an attribute value.
	//
	//     * PutRequest - Perform a PutItem
	// operation on the specified item. The item to be put is identified by an Item
	// subelement:
	//
	//         * Item - A map of attributes and their values. Each entry
	// in this map consists of an attribute name and an attribute value. Attribute
	// values must not be null; string and binary type attributes must have lengths
	// greater than zero; and set type attributes must not be empty. Requests that
	// contain empty values will be rejected with a ValidationException exception. If
	// you specify any attributes that are part of an index key, then the data types
	// for those attributes must match those of the schema in the table's attribute
	// definition.
	//
	// If there are no unprocessed items remaining, the response contains
	// an empty UnprocessedItems map.
	UnprocessedItems map[string][]*types.WriteRequest
	// The capacity units consumed by the entire BatchWriteItem operation. Each element
	// consists of:
	//
	//     * TableName - The table that consumed the provisioned
	// throughput.
	//
	//     * CapacityUnits - The total number of capacity units consumed.
	ConsumedCapacity []*types.ConsumedCapacity
	// A list of tables that were processed by BatchWriteItem and, for each table,
	// information about any item collections that were affected by individual
	// DeleteItem or PutItem operations. Each entry consists of the following
	// subelements:
	//
	//     * ItemCollectionKey - The partition key value of the item
	// collection. This is the same as the partition key value of the item.
	//
	//     *
	// SizeEstimateRangeGB - An estimate of item collection size, expressed in GB. This
	// is a two-element array containing a lower bound and an upper bound for the
	// estimate. The estimate includes the size of all the items in the table, plus the
	// size of all attributes projected into all of the local secondary indexes on the
	// table. Use this estimate to measure whether a local secondary index is
	// approaching its size limit. The estimate is subject to change over time;
	// therefore, do not rely on the precision or accuracy of the estimate.
	ItemCollectionMetrics map[string][]*types.ItemCollectionMetrics

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Client struct {
	// contains filtered or unexported fields
}

type CreateBackupInput struct {
	// The name of the table.
	TableName *string
	// Specified name for the backup.
	BackupName *string
}

type CreateBackupOutput struct {
	// Contains the details of the backup created for the table.
	BackupDetails *types.BackupDetails

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateGlobalTableInput struct {
	// The global table name.
	GlobalTableName *string
	// The Regions where the global table needs to be created.
	ReplicationGroup []*types.Replica
}

type CreateGlobalTableOutput struct {
	// Contains the details of the global table.
	GlobalTableDescription *types.GlobalTableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateTableInput struct {
	// Represents the settings used to enable server-side encryption.
	SSESpecification *types.SSESpecification
	// The settings for DynamoDB Streams on the table. These settings consist of:
	//
	//
	// * StreamEnabled - Indicates whether DynamoDB Streams is to be enabled (true) or
	// disabled (false).
	//
	//     * StreamViewType - When an item in the table is modified,
	// StreamViewType determines what information is written to the table's stream.
	// Valid values for StreamViewType are:
	//
	//         * KEYS_ONLY - Only the key
	// attributes of the modified item are written to the stream.
	//
	//         * NEW_IMAGE
	// - The entire item, as it appears after it was modified, is written to the
	// stream.
	//
	//         * OLD_IMAGE - The entire item, as it appeared before it was
	// modified, is written to the stream.
	//
	//         * NEW_AND_OLD_IMAGES - Both the new
	// and the old item images of the item are written to the stream.
	StreamSpecification *types.StreamSpecification
	// Specifies the attributes that make up the primary key for a table or an index.
	// The attributes in KeySchema must also be defined in the AttributeDefinitions
	// array. For more information, see Data Model
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataModel.html)
	// in the Amazon DynamoDB Developer Guide. Each KeySchemaElement in the array is
	// composed of:
	//
	//     * AttributeName - The name of this key attribute.
	//
	//     *
	// KeyType - The role that the key attribute will assume:
	//
	//         * HASH -
	// partition key
	//
	//         * RANGE - sort key
	//
	// The partition key of an item is also
	// known as its hash attribute. The term "hash attribute" derives from the DynamoDB
	// 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.  <p>For a simple primary key (partition
	// key), you must provide exactly one element with a <code>KeyType</code> of
	// <code>HASH</code>.</p> <p>For a composite primary key (partition key and sort
	// key), you must provide exactly two elements, in this order: The first element
	// must have a <code>KeyType</code> of <code>HASH</code>, and the second element
	// must have a <code>KeyType</code> of <code>RANGE</code>.</p> <p>For more
	// information, see <a
	// href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#WorkingWithTables.primary.key">Working
	// with Tables</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
	KeySchema []*types.KeySchemaElement
	// An array of attributes that describe the key schema for the table and indexes.
	AttributeDefinitions []*types.AttributeDefinition
	// One or more global secondary indexes (the maximum is 20) to be created on the
	// table. Each global secondary index in the array includes the following:
	//
	//     *
	// IndexName - The name of the global secondary index. Must be unique only for this
	// table.
	//
	//     * KeySchema - Specifies the key schema for the global secondary
	// index.
	//
	//     * Projection - Specifies attributes that are copied (projected) from
	// the table into the index. These are in addition to the primary key attributes
	// and index key attributes, which are automatically projected. Each attribute
	// specification is composed of:
	//
	//         * ProjectionType - One of the
	// following:
	//
	//             * KEYS_ONLY - Only the index and primary keys are
	// projected into the index.
	//
	//             * INCLUDE - Only the specified table
	// attributes are projected into the index. The list of projected attributes is in
	// NonKeyAttributes.
	//
	//             * ALL - All of the table attributes are projected
	// into the index.
	//
	//         * NonKeyAttributes - A list of one or more non-key
	// attribute names that are projected into the secondary index. The total count of
	// attributes provided in NonKeyAttributes, summed across all of the secondary
	// indexes, must not exceed 100. If you project the same attribute into two
	// different indexes, this counts as two distinct attributes when determining the
	// total.
	//
	//     * ProvisionedThroughput - The provisioned throughput settings for
	// the global secondary index, consisting of read and write capacity units.
	GlobalSecondaryIndexes []*types.GlobalSecondaryIndex
	// Controls how you are charged for read and write throughput and how you manage
	// capacity. This setting can be changed later.
	//
	//     * PROVISIONED - We recommend
	// using PROVISIONED for predictable workloads. PROVISIONED sets the billing mode
	// to Provisioned Mode
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.ProvisionedThroughput.Manual).
	//
	//
	// * PAY_PER_REQUEST - We recommend using PAY_PER_REQUEST for unpredictable
	// workloads. PAY_PER_REQUEST sets the billing mode to On-Demand Mode
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.OnDemand).
	BillingMode types.BillingMode
	// One or more local secondary indexes (the maximum is 5) to be created on the
	// table. Each index is scoped to a given partition key value. There is a 10 GB
	// size limit per partition key value; otherwise, the size of a local secondary
	// index is unconstrained. Each local secondary index in the array includes the
	// following:
	//
	//     * IndexName - The name of the local secondary index. Must be
	// unique only for this table.
	//
	//     * KeySchema - Specifies the key schema for the
	// local secondary index. The key schema must begin with the same partition key as
	// the table.
	//
	//     * Projection - Specifies attributes that are copied (projected)
	// from the table into the index. These are in addition to the primary key
	// attributes and index key attributes, which are automatically projected. Each
	// attribute specification is composed of:
	//
	//         * ProjectionType - One of the
	// following:
	//
	//             * KEYS_ONLY - Only the index and primary keys are
	// projected into the index.
	//
	//             * INCLUDE - Only the specified table
	// attributes are projected into the index. The list of projected attributes is in
	// NonKeyAttributes.
	//
	//             * ALL - All of the table attributes are projected
	// into the index.
	//
	//         * NonKeyAttributes - A list of one or more non-key
	// attribute names that are projected into the secondary index. The total count of
	// attributes provided in NonKeyAttributes, summed across all of the secondary
	// indexes, must not exceed 100. If you project the same attribute into two
	// different indexes, this counts as two distinct attributes when determining the
	// total.
	LocalSecondaryIndexes []*types.LocalSecondaryIndex
	// Represents the provisioned throughput settings for a specified table or index.
	// The settings can be modified using the UpdateTable operation. If you set
	// BillingMode as PROVISIONED, you must specify this property. If you set
	// BillingMode as PAY_PER_REQUEST, you cannot specify this property. For current
	// minimum and maximum provisioned throughput values, see Limits
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html)
	// in the Amazon DynamoDB Developer Guide.
	ProvisionedThroughput *types.ProvisionedThroughput
	// A list of key-value pairs to label the table. For more information, see Tagging
	// for DynamoDB
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html).
	Tags []*types.Tag
	// The name of the table to create.
	TableName *string
}

type CreateTableOutput struct {
	// Represents the properties of the table.
	TableDescription *types.TableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteBackupInput struct {
	// The ARN associated with the backup.
	BackupArn *string
}

type DeleteBackupOutput struct {
	// Contains the description of the backup created for the table.
	BackupDescription *types.BackupDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteItemInput struct {
	// One or more values that can be substituted in an expression. Use the : (colon)
	// character in an expression to dereference an attribute value. For example,
	// suppose that you wanted to check whether the value of the ProductStatus
	// attribute was one of the following: Available | Backordered | Discontinued You
	// would first need to specify ExpressionAttributeValues as follows: {
	// ":avail":{"S":"Available"}, ":back":{"S":"Backordered"},
	// ":disc":{"S":"Discontinued"} } You could then use these values in an expression,
	// such as this: ProductStatus IN (:avail, :back, :disc) For more information on
	// expression attribute values, see Condition Expressions
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html)
	// in the Amazon DynamoDB Developer Guide.
	ExpressionAttributeValues map[string]*types.AttributeValue
	// A condition that must be satisfied in order for a conditional DeleteItem to
	// succeed. An expression can contain any of the following:
	//
	//     * Functions:
	// attribute_exists | attribute_not_exists | attribute_type | contains |
	// begins_with | size These function names are case-sensitive.
	//
	//     * Comparison
	// operators: = | <> | < | > | <= | >= | BETWEEN | IN
	//
	//     * Logical operators: AND
	// | OR | NOT
	//
	// For more information about condition expressions, see Condition
	// Expressions
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html)
	// in the Amazon DynamoDB Developer Guide.
	ConditionExpression *string
	// A map of attribute names to AttributeValue objects, representing the primary key
	// of the item to delete. For the primary key, you must provide all of the
	// attributes. For example, with a simple primary key, you only need to provide a
	// value for the partition key. For a composite primary key, you must provide
	// values for both the partition key and the sort key.
	Key map[string]*types.AttributeValue
	// This is a legacy parameter. Use ConditionExpression instead. For more
	// information, see Expected
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.Expected.html)
	// in the Amazon DynamoDB Developer Guide.
	Expected map[string]*types.ExpectedAttributeValue
	// This is a legacy parameter. Use ConditionExpression instead. For more
	// information, see ConditionalOperator
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html)
	// in the Amazon DynamoDB Developer Guide.
	ConditionalOperator types.ConditionalOperator
	// Determines the level of detail about provisioned throughput consumption that is
	// returned in the response:
	//
	//     * INDEXES - The response includes the aggregate
	// ConsumedCapacity for the operation, together with ConsumedCapacity for each
	// table and secondary index that was accessed. Note that some operations, such as
	// GetItem and BatchGetItem, do not access any indexes at all. In these cases,
	// specifying INDEXES will only return ConsumedCapacity information for table(s).
	//
	//
	// * TOTAL - The response includes only the aggregate ConsumedCapacity for the
	// operation.
	//
	//     * NONE - No ConsumedCapacity details are included in the
	// response.
	ReturnConsumedCapacity types.ReturnConsumedCapacity
	// Use ReturnValues if you want to get the item attributes as they appeared before
	// they were deleted. For DeleteItem, the valid values are:
	//
	//     * NONE - If
	// ReturnValues is not specified, or if its value is NONE, then nothing is
	// returned. (This setting is the default for ReturnValues.)
	//
	//     * ALL_OLD - The
	// content of the old item is returned.
	//
	// The ReturnValues parameter is used by
	// several DynamoDB operations; however, DeleteItem does not recognize any values
	// other than NONE or ALL_OLD.
	ReturnValues types.ReturnValue
	// One or more substitution tokens for attribute names in an expression. The
	// following are some use cases for using ExpressionAttributeNames:
	//
	//     * To
	// access an attribute whose name conflicts with a DynamoDB reserved word.
	//
	//     *
	// To create a placeholder for repeating occurrences of an attribute name in an
	// expression.
	//
	//     * To prevent special characters in an attribute name from being
	// misinterpreted in an expression.
	//
	// Use the # character in an expression to
	// dereference an attribute name. For example, consider the following attribute
	// name:
	//
	//     * Percentile
	//
	// The name of this attribute conflicts with a reserved
	// word, so it cannot be used directly in an expression. (For the complete list of
	// reserved words, see Reserved Words
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html)
	// in the Amazon DynamoDB Developer Guide). To work around this, you could specify
	// the following for ExpressionAttributeNames:
	//
	//     * {"#P":"Percentile"}
	//
	// You
	// could then use this substitution in an expression, as in this example:
	//
	//     * #P
	// = :val
	//
	// Tokens that begin with the : character are expression attribute values,
	// which are placeholders for the actual value at runtime. For more information on
	// expression attribute names, see Specifying Item Attributes
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html)
	// in the Amazon DynamoDB Developer Guide.
	ExpressionAttributeNames map[string]*string
	// Determines whether item collection metrics are returned. If set to SIZE, the
	// response includes statistics about item collections, if any, that were modified
	// during the operation are returned in the response. If set to NONE (the default),
	// no statistics are returned.
	ReturnItemCollectionMetrics types.ReturnItemCollectionMetrics
	// The name of the table from which to delete the item.
	TableName *string
}

type DeleteItemOutput struct {
	// Information about item collections, if any, that were affected by the DeleteItem
	// operation. ItemCollectionMetrics is only returned if the
	// ReturnItemCollectionMetrics parameter was specified. If the table does not have
	// any local secondary indexes, this information is not returned in the response.
	// Each ItemCollectionMetrics element consists of:
	//
	//     * ItemCollectionKey - The
	// partition key value of the item collection. This is the same as the partition
	// key value of the item itself.
	//
	//     * SizeEstimateRangeGB - An estimate of item
	// collection size, in gigabytes. This value is a two-element array containing a
	// lower bound and an upper bound for the estimate. The estimate includes the size
	// of all the items in the table, plus the size of all attributes projected into
	// all of the local secondary indexes on that table. Use this estimate to measure
	// whether a local secondary index is approaching its size limit. The estimate is
	// subject to change over time; therefore, do not rely on the precision or accuracy
	// of the estimate.
	ItemCollectionMetrics *types.ItemCollectionMetrics
	// A map of attribute names to AttributeValue objects, representing the item as it
	// appeared before the DeleteItem operation. This map appears in the response only
	// if ReturnValues was specified as ALL_OLD in the request.
	Attributes map[string]*types.AttributeValue
	// The capacity units consumed by the DeleteItem operation. The data returned
	// includes the total provisioned throughput consumed, along with statistics for
	// the table and any indexes involved in the operation. ConsumedCapacity is only
	// returned if the ReturnConsumedCapacity parameter was specified. For more
	// information, see Provisioned Mode
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html)
	// in the Amazon DynamoDB Developer Guide.
	ConsumedCapacity *types.ConsumedCapacity

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteTableInput struct {
	// The name of the table to delete.
	TableName *string
}

type DeleteTableOutput struct {
	// Represents the properties of a table.
	TableDescription *types.TableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeBackupInput struct {
	// The Amazon Resource Name (ARN) associated with the backup.
	BackupArn *string
}

type DescribeBackupOutput struct {
	// Contains the description of the backup created for the table.
	BackupDescription *types.BackupDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeContinuousBackupsInput struct {
	// Name of the table for which the customer wants to check the continuous backups
	// and point in time recovery settings.
	TableName *string
}

type DescribeContinuousBackupsOutput struct {
	// Represents the continuous backups and point in time recovery settings on the
	// table.
	ContinuousBackupsDescription *types.ContinuousBackupsDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeContributorInsightsInput struct {
	// The name of the global secondary index to describe, if applicable.
	IndexName *string
	// The name of the table to describe.
	TableName *string
}

type DescribeContributorInsightsOutput struct {
	// Returns information about the last failure that encountered. The most common
	// exceptions for a FAILED status are:
	//
	//     * LimitExceededException - Per-account
	// Amazon CloudWatch Contributor Insights rule limit reached. Please disable
	// Contributor Insights for other tables/indexes OR disable Contributor Insights
	// rules before retrying.
	//
	//     * AccessDeniedException - Amazon CloudWatch
	// Contributor Insights rules cannot be modified due to insufficient permissions.
	//
	//
	// * AccessDeniedException - Failed to create service-linked role for Contributor
	// Insights due to insufficient permissions.
	//
	//     * InternalServerError - Failed to
	// create Amazon CloudWatch Contributor Insights rules. Please retry request.
	FailureException *types.FailureException
	// List of names of the associated Alpine rules.
	ContributorInsightsRuleList []*string
	// The name of the table being described.
	TableName *string
	// Current Status contributor insights.
	ContributorInsightsStatus types.ContributorInsightsStatus
	// Timestamp of the last time the status was changed.
	LastUpdateDateTime *time.Time
	// The name of the global secondary index being described.
	IndexName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeEndpointsInput struct {
}

type DescribeEndpointsOutput struct {
	// List of endpoints.
	Endpoints []*types.Endpoint

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeGlobalTableInput struct {
	// The name of the global table.
	GlobalTableName *string
}

type DescribeGlobalTableOutput struct {
	// Contains the details of the global table.
	GlobalTableDescription *types.GlobalTableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeGlobalTableSettingsInput struct {
	// The name of the global table to describe.
	GlobalTableName *string
}

type DescribeGlobalTableSettingsOutput struct {
	// The Region-specific settings for the global table.
	ReplicaSettings []*types.ReplicaSettingsDescription
	// The name of the global table.
	GlobalTableName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeLimitsInput struct {
}

type DescribeLimitsOutput struct {
	// The maximum total write capacity units that your account allows you to provision
	// across all of your tables in this Region.
	AccountMaxWriteCapacityUnits *int64
	// The maximum write capacity units that your account allows you to provision for a
	// new table that you are creating in this Region, including the write capacity
	// units provisioned for its global secondary indexes (GSIs).
	TableMaxWriteCapacityUnits *int64
	// The maximum read capacity units that your account allows you to provision for a
	// new table that you are creating in this Region, including the read capacity
	// units provisioned for its global secondary indexes (GSIs).
	TableMaxReadCapacityUnits *int64
	// The maximum total read capacity units that your account allows you to provision
	// across all of your tables in this Region.
	AccountMaxReadCapacityUnits *int64

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeTableInput struct {
	// The name of the table to describe.
	TableName *string
}

type DescribeTableOutput struct {
	// The properties of the table.
	Table *types.TableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeTableReplicaAutoScalingInput struct {
	// The name of the table.
	TableName *string
}

type DescribeTableReplicaAutoScalingOutput struct {
	// Represents the auto scaling properties of the table.
	TableAutoScalingDescription *types.TableAutoScalingDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeTimeToLiveInput struct {
	// The name of the table to be described.
	TableName *string
}

type DescribeTimeToLiveOutput struct {
	//
	TimeToLiveDescription *types.TimeToLiveDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type EndpointResolver interface {
	ResolveEndpoint(region string, options ResolverOptions) (aws.Endpoint, error)
}

type EndpointResolverFunc func(region string, options ResolverOptions) (aws.Endpoint, error)

type GetItemInput struct {
	// A string that identifies one or more attributes to retrieve from the table.
	// These attributes can include scalars, sets, or elements of a JSON document. The
	// attributes in the expression must be separated by commas. If no attribute names
	// are specified, then all attributes are returned. If any of the requested
	// attributes are not found, they do not appear in the result. For more
	// information, see Specifying Item Attributes
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html)
	// in the Amazon DynamoDB Developer Guide.
	ProjectionExpression *string
	// The name of the table containing the requested item.
	TableName *string
	// This is a legacy parameter. Use ProjectionExpression instead. For more
	// information, see AttributesToGet
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html)
	// in the Amazon DynamoDB Developer Guide.
	AttributesToGet []*string
	// One or more substitution tokens for attribute names in an expression. The
	// following are some use cases for using ExpressionAttributeNames:
	//
	//     * To
	// access an attribute whose name conflicts with a DynamoDB reserved word.
	//
	//     *
	// To create a placeholder for repeating occurrences of an attribute name in an
	// expression.
	//
	//     * To prevent special characters in an attribute name from being
	// misinterpreted in an expression.
	//
	// Use the # character in an expression to
	// dereference an attribute name. For example, consider the following attribute
	// name:
	//
	//     * Percentile
	//
	// The name of this attribute conflicts with a reserved
	// word, so it cannot be used directly in an expression. (For the complete list of
	// reserved words, see Reserved Words
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html)
	// in the Amazon DynamoDB Developer Guide). To work around this, you could specify
	// the following for ExpressionAttributeNames:
	//
	//     * {"#P":"Percentile"}
	//
	// You
	// could then use this substitution in an expression, as in this example:
	//
	//     * #P
	// = :val
	//
	// Tokens that begin with the : character are expression attribute values,
	// which are placeholders for the actual value at runtime. For more information on
	// expression attribute names, see Specifying Item Attributes
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html)
	// in the Amazon DynamoDB Developer Guide.
	ExpressionAttributeNames map[string]*string
	// Determines the level of detail about provisioned throughput consumption that is
	// returned in the response:
	//
	//     * INDEXES - The response includes the aggregate
	// ConsumedCapacity for the operation, together with ConsumedCapacity for each
	// table and secondary index that was accessed. Note that some operations, such as
	// GetItem and BatchGetItem, do not access any indexes at all. In these cases,
	// specifying INDEXES will only return ConsumedCapacity information for table(s).
	//
	//
	// * TOTAL - The response includes only the aggregate ConsumedCapacity for the
	// operation.
	//
	//     * NONE - No ConsumedCapacity details are included in the
	// response.
	ReturnConsumedCapacity types.ReturnConsumedCapacity
	// A map of attribute names to AttributeValue objects, representing the primary key
	// of the item to retrieve. For the primary key, you must provide all of the
	// attributes. For example, with a simple primary key, you only need to provide a
	// value for the partition key. For a composite primary key, you must provide
	// values for both the partition key and the sort key.
	Key map[string]*types.AttributeValue
	// Determines the read consistency model: If set to true, then the operation uses
	// strongly consistent reads; otherwise, the operation uses eventually consistent
	// reads.
	ConsistentRead *bool
}

type GetItemOutput struct {
	// The capacity units consumed by the GetItem operation. The data returned includes
	// the total provisioned throughput consumed, along with statistics for the table
	// and any indexes involved in the operation. ConsumedCapacity is only returned if
	// the ReturnConsumedCapacity parameter was specified. For more information, see
	// Read/Write Capacity Mode
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html)
	// in the Amazon DynamoDB Developer Guide.
	ConsumedCapacity *types.ConsumedCapacity
	// A map of attribute names to AttributeValue objects, as specified by
	// ProjectionExpression.
	Item map[string]*types.AttributeValue

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type HTTPClient interface {
	Do(*http.Request) (*http.Response, error)
}

type HTTPSignerV4 interface {
	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time) error
}

type IdempotencyTokenProvider interface {
	GetIdempotencyToken() (string, error)
}

type ListBackupsInput struct {
	// The backups from the table specified by BackupType are listed. Where BackupType
	// can be:
	//
	//     * USER - On-demand backup created by you.
	//
	//     * SYSTEM - On-demand
	// backup automatically created by DynamoDB.
	//
	//     * ALL - All types of on-demand
	// backups (USER and SYSTEM).
	BackupType types.BackupTypeFilter
	// Only backups created before this time are listed. TimeRangeUpperBound is
	// exclusive.
	TimeRangeUpperBound *time.Time
	// LastEvaluatedBackupArn is the Amazon Resource Name (ARN) of the backup last
	// evaluated when the current page of results was returned, inclusive of the
	// current page of results. This value may be specified as the
	// ExclusiveStartBackupArn of a new ListBackups operation in order to fetch the
	// next page of results.
	ExclusiveStartBackupArn *string
	// Only backups created after this time are listed. TimeRangeLowerBound is
	// inclusive.
	TimeRangeLowerBound *time.Time
	// The backups from the table specified by TableName are listed.
	TableName *string
	// Maximum number of backups to return at once.
	Limit *int32
}

type ListBackupsOutput struct {
	// List of BackupSummary objects.
	BackupSummaries []*types.BackupSummary
	// The ARN of the backup last evaluated when the current page of results was
	// returned, inclusive of the current page of results. This value may be specified
	// as the ExclusiveStartBackupArn of a new ListBackups operation in order to fetch
	// the next page of results. If LastEvaluatedBackupArn is empty, then the last page
	// of results has been processed and there are no more results to be retrieved. If
	// LastEvaluatedBackupArn is not empty, this may or may not indicate that there is
	// more data to be returned. All results are guaranteed to have been returned if
	// and only if no value for LastEvaluatedBackupArn is returned.
	LastEvaluatedBackupArn *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListContributorInsightsInput struct {
	// The name of the table.
	TableName *string
	// Maximum number of results to return per page.
	MaxResults *int32
	// A token to for the desired page, if there is one.
	NextToken *string
}

type ListContributorInsightsOutput struct {
	// A token to go to the next page if there is one.
	NextToken *string
	// A list of ContributorInsightsSummary.
	ContributorInsightsSummaries []*types.ContributorInsightsSummary

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListGlobalTablesInput struct {
	// The first global table name that this operation will evaluate.
	ExclusiveStartGlobalTableName *string
	// The maximum number of table names to return, if the parameter is not specified
	// DynamoDB defaults to 100. If the number of global tables DynamoDB finds reaches
	// this limit, it stops the operation and returns the table names collected up to
	// that point, with a table name in the LastEvaluatedGlobalTableName to apply in a
	// subsequent operation to the ExclusiveStartGlobalTableName parameter.
	Limit *int32
	// Lists the global tables in a specific Region.
	RegionName *string
}

type ListGlobalTablesOutput struct {
	// List of global table names.
	GlobalTables []*types.GlobalTable
	// Last evaluated global table name.
	LastEvaluatedGlobalTableName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListTablesInput struct {
	// A maximum number of table names to return. If this parameter is not specified,
	// the limit is 100.
	Limit *int32
	// The first table name that this operation will evaluate. Use the value that was
	// returned for LastEvaluatedTableName in a previous operation, so that you can
	// obtain the next page of results.
	ExclusiveStartTableName *string
}

type ListTablesOutput struct {
	// The names of the tables associated with the current account at the current
	// endpoint. The maximum size of this array is 100. If LastEvaluatedTableName also
	// appears in the output, you can use this value as the ExclusiveStartTableName
	// parameter in a subsequent ListTables request and obtain the next page of
	// results.
	TableNames []*string
	// The name of the last table in the current page of results. Use this value as the
	// ExclusiveStartTableName in a new request to obtain the next page of results,
	// until all the table names are returned. If you do not receive a
	// LastEvaluatedTableName value in the response, this means that there are no more
	// table names to be retrieved.
	LastEvaluatedTableName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListTagsOfResourceInput struct {
	// An optional string that, if supplied, must be copied from the output of a
	// previous call to ListTagOfResource. When provided in this manner, this API
	// fetches the next page of results.
	NextToken *string
	// The Amazon DynamoDB resource with tags to be listed. This value is an Amazon
	// Resource Name (ARN).
	ResourceArn *string
}

type ListTagsOfResourceOutput struct {
	// If this value is returned, there are additional results to be displayed. To
	// retrieve them, call ListTagsOfResource again, with NextToken set to this value.
	NextToken *string
	// The tags currently associated with the Amazon DynamoDB resource.
	Tags []*types.Tag

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Options struct {
	// Set of options to modify how an operation is invoked. These apply to all
	// operations invoked for this client. Use functional options on operation call to
	// modify this list for per operation behavior.
	APIOptions []func(*middleware.Stack) error

	// The credentials object to use when signing requests.
	Credentials aws.CredentialsProvider

	// Allows you to disable the client's validation of response integrity using CRC32
	// checksum. Enabled by default.
	DisableValidateResponseChecksum bool

	// Allows you to enable the client's support for compressed gzip responses.
	// Disabled by default.
	EnableAcceptEncodingGzip bool

	// The endpoint options to be used when attempting to resolve an endpoint.
	EndpointOptions ResolverOptions

	// The service endpoint resolver.
	EndpointResolver EndpointResolver

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// Provides idempotency tokens values that will be automatically populated into
	// idempotent API operations.
	IdempotencyTokenProvider IdempotencyTokenProvider

	// The region to send requests to. (Required)
	Region string

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer.
	Retryer retry.Retryer

	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
	// implementation if nil.
	HTTPClient HTTPClient
}

type PutItemInput struct {
	// Determines whether item collection metrics are returned. If set to SIZE, the
	// response includes statistics about item collections, if any, that were modified
	// during the operation are returned in the response. If set to NONE (the default),
	// no statistics are returned.
	ReturnItemCollectionMetrics types.ReturnItemCollectionMetrics
	// One or more substitution tokens for attribute names in an expression. The
	// following are some use cases for using ExpressionAttributeNames:
	//
	//     * To
	// access an attribute whose name conflicts with a DynamoDB reserved word.
	//
	//     *
	// To create a placeholder for repeating occurrences of an attribute name in an
	// expression.
	//
	//     * To prevent special characters in an attribute name from being
	// misinterpreted in an expression.
	//
	// Use the # character in an expression to
	// dereference an attribute name. For example, consider the following attribute
	// name:
	//
	//     * Percentile
	//
	// The name of this attribute conflicts with a reserved
	// word, so it cannot be used directly in an expression. (For the complete list of
	// reserved words, see Reserved Words
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html)
	// in the Amazon DynamoDB Developer Guide). To work around this, you could specify
	// the following for ExpressionAttributeNames:
	//
	//     * {"#P":"Percentile"}
	//
	// You
	// could then use this substitution in an expression, as in this example:
	//
	//     * #P
	// = :val
	//
	// Tokens that begin with the : character are expression attribute values,
	// which are placeholders for the actual value at runtime. For more information on
	// expression attribute names, see Specifying Item Attributes
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html)
	// in the Amazon DynamoDB Developer Guide.
	ExpressionAttributeNames map[string]*string
	// Use ReturnValues if you want to get the item attributes as they appeared before
	// they were updated with the PutItem request. For PutItem, the valid values are:
	//
	//
	// * NONE - If ReturnValues is not specified, or if its value is NONE, then nothing
	// is returned. (This setting is the default for ReturnValues.)
	//
	//     * ALL_OLD - If
	// PutItem overwrote an attribute name-value pair, then the content of the old item
	// is returned.
	//
	// The ReturnValues parameter is used by several DynamoDB operations;
	// however, PutItem does not recognize any values other than NONE or ALL_OLD.
	ReturnValues types.ReturnValue
	// The name of the table to contain the item.
	TableName *string
	// A map of attribute name/value pairs, one for each attribute. Only the primary
	// key attributes are required; you can optionally provide other attribute
	// name-value pairs for the item. You must provide all of the attributes for the
	// primary key. For example, with a simple primary key, you only need to provide a
	// value for the partition key. For a composite primary key, you must provide both
	// values for both the partition key and the sort key. If you specify any
	// attributes that are part of an index key, then the data types for those
	// attributes must match those of the schema in the table's attribute definition.
	// Empty String and Binary attribute values are allowed. Attribute values of type
	// String and Binary must have a length greater than zero if the attribute is used
	// as a key attribute for a table or index.  <p>For more information about primary
	// keys, see <a
	// href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey">Primary
	// Key</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> <p>Each element in
	// the <code>Item</code> map is an <code>AttributeValue</code> object.</p>
	Item map[string]*types.AttributeValue
	// Determines the level of detail about provisioned throughput consumption that is
	// returned in the response:
	//
	//     * INDEXES - The response includes the aggregate
	// ConsumedCapacity for the operation, together with ConsumedCapacity for each
	// table and secondary index that was accessed. Note that some operations, such as
	// GetItem and BatchGetItem, do not access any indexes at all. In these cases,
	// specifying INDEXES will only return ConsumedCapacity information for table(s).
	//
	//
	// * TOTAL - The response includes only the aggregate ConsumedCapacity for the
	// operation.
	//
	//     * NONE - No ConsumedCapacity details are included in the
	// response.
	ReturnConsumedCapacity types.ReturnConsumedCapacity
	// One or more values that can be substituted in an expression. Use the : (colon)
	// character in an expression to dereference an attribute value. For example,
	// suppose that you wanted to check whether the value of the ProductStatus
	// attribute was one of the following: Available | Backordered | Discontinued You
	// would first need to specify ExpressionAttributeValues as follows: {
	// ":avail":{"S":"Available"}, ":back":{"S":"Backordered"},
	// ":disc":{"S":"Discontinued"} } You could then use these values in an expression,
	// such as this: ProductStatus IN (:avail, :back, :disc) For more information on
	// expression attribute values, see Condition Expressions
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html)
	// in the Amazon DynamoDB Developer Guide.
	ExpressionAttributeValues map[string]*types.AttributeValue
	// A condition that must be satisfied in order for a conditional PutItem operation
	// to succeed. An expression can contain any of the following:
	//
	//     * Functions:
	// attribute_exists | attribute_not_exists | attribute_type | contains |
	// begins_with | size These function names are case-sensitive.
	//
	//     * Comparison
	// operators: = | <> | < | > | <= | >= | BETWEEN | IN
	//
	//     * Logical operators: AND
	// | OR | NOT
	//
	// For more information on condition expressions, see Condition
	// Expressions
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html)
	// in the Amazon DynamoDB Developer Guide.
	ConditionExpression *string
	// This is a legacy parameter. Use ConditionExpression instead. For more
	// information, see ConditionalOperator
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html)
	// in the Amazon DynamoDB Developer Guide.
	ConditionalOperator types.ConditionalOperator
	// This is a legacy parameter. Use ConditionExpression instead. For more
	// information, see Expected
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.Expected.html)
	// in the Amazon DynamoDB Developer Guide.
	Expected map[string]*types.ExpectedAttributeValue
}

type PutItemOutput struct {
	// Information about item collections, if any, that were affected by the PutItem
	// operation. ItemCollectionMetrics is only returned if the
	// ReturnItemCollectionMetrics parameter was specified. If the table does not have
	// any local secondary indexes, this information is not returned in the response.
	// Each ItemCollectionMetrics element consists of:
	//
	//     * ItemCollectionKey - The
	// partition key value of the item collection. This is the same as the partition
	// key value of the item itself.
	//
	//     * SizeEstimateRangeGB - An estimate of item
	// collection size, in gigabytes. This value is a two-element array containing a
	// lower bound and an upper bound for the estimate. The estimate includes the size
	// of all the items in the table, plus the size of all attributes projected into
	// all of the local secondary indexes on that table. Use this estimate to measure
	// whether a local secondary index is approaching its size limit. The estimate is
	// subject to change over time; therefore, do not rely on the precision or accuracy
	// of the estimate.
	ItemCollectionMetrics *types.ItemCollectionMetrics
	// The capacity units consumed by the PutItem operation. The data returned includes
	// the total provisioned throughput consumed, along with statistics for the table
	// and any indexes involved in the operation. ConsumedCapacity is only returned if
	// the ReturnConsumedCapacity parameter was specified. For more information, see
	// Read/Write Capacity Mode
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html)
	// in the Amazon DynamoDB Developer Guide.
	ConsumedCapacity *types.ConsumedCapacity
	// The attribute values as they appeared before the PutItem operation, but only if
	// ReturnValues is specified as ALL_OLD in the request. Each element consists of an
	// attribute name and an attribute value.
	Attributes map[string]*types.AttributeValue

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type QueryInput struct {
	// This is a legacy parameter. Use KeyConditionExpression instead. For more
	// information, see KeyConditions
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html)
	// in the Amazon DynamoDB Developer Guide.
	KeyConditions map[string]*types.Condition
	// Specifies the order for index traversal: If true (default), the traversal is
	// performed in ascending order; if false, the traversal is performed in descending
	// order. Items with the same partition key value are stored in sorted order by
	// sort key. If the sort key data type is Number, the results are stored in numeric
	// order. For type String, the results are stored in order of UTF-8 bytes. For type
	// Binary, DynamoDB treats each byte of the binary data as unsigned. If
	// ScanIndexForward is true, DynamoDB returns the results in the order in which
	// they are stored (by sort key value). This is the default behavior. If
	// ScanIndexForward is false, DynamoDB reads the results in reverse order by sort
	// key value, and then returns the results to the client.
	ScanIndexForward *bool
	// This is a legacy parameter. Use FilterExpression instead. For more information,
	// see QueryFilter
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html)
	// in the Amazon DynamoDB Developer Guide.
	QueryFilter map[string]*types.Condition
	// The name of the table containing the requested items.
	TableName *string
	// The name of an index to query. This index can be any local secondary index or
	// global secondary index on the table. Note that if you use the IndexName
	// parameter, you must also provide TableName.
	IndexName *string
	// Determines the level of detail about provisioned throughput consumption that is
	// returned in the response:
	//
	//     * INDEXES - The response includes the aggregate
	// ConsumedCapacity for the operation, together with ConsumedCapacity for each
	// table and secondary index that was accessed. Note that some operations, such as
	// GetItem and BatchGetItem, do not access any indexes at all. In these cases,
	// specifying INDEXES will only return ConsumedCapacity information for table(s).
	//
	//
	// * TOTAL - The response includes only the aggregate ConsumedCapacity for the
	// operation.
	//
	//     * NONE - No ConsumedCapacity details are included in the
	// response.
	ReturnConsumedCapacity types.ReturnConsumedCapacity
	// One or more substitution tokens for attribute names in an expression. The
	// following are some use cases for using ExpressionAttributeNames:
	//
	//     * To
	// access an attribute whose name conflicts with a DynamoDB reserved word.
	//
	//     *
	// To create a placeholder for repeating occurrences of an attribute name in an
	// expression.
	//
	//     * To prevent special characters in an attribute name from being
	// misinterpreted in an expression.
	//
	// Use the # character in an expression to
	// dereference an attribute name. For example, consider the following attribute
	// name:
	//
	//     * Percentile
	//
	// The name of this attribute conflicts with a reserved
	// word, so it cannot be used directly in an expression. (For the complete list of
	// reserved words, see Reserved Words
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html)
	// in the Amazon DynamoDB Developer Guide). To work around this, you could specify
	// the following for ExpressionAttributeNames:
	//
	//     * {"#P":"Percentile"}
	//
	// You
	// could then use this substitution in an expression, as in this example:
	//
	//     * #P
	// = :val
	//
	// Tokens that begin with the : character are expression attribute values,
	// which are placeholders for the actual value at runtime. For more information on
	// expression attribute names, see Specifying Item Attributes
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html)
	// in the Amazon DynamoDB Developer Guide.
	ExpressionAttributeNames map[string]*string
	// This is a legacy parameter. Use ProjectionExpression instead. For more
	// information, see AttributesToGet
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html)
	// in the Amazon DynamoDB Developer Guide.
	AttributesToGet []*string
	// One or more values that can be substituted in an expression. Use the : (colon)
	// character in an expression to dereference an attribute value. For example,
	// suppose that you wanted to check whether the value of the ProductStatus
	// attribute was one of the following: Available | Backordered | Discontinued You
	// would first need to specify ExpressionAttributeValues as follows: {
	// ":avail":{"S":"Available"}, ":back":{"S":"Backordered"},
	// ":disc":{"S":"Discontinued"} } You could then use these values in an expression,
	// such as this: ProductStatus IN (:avail, :back, :disc) For more information on
	// expression attribute values, see Specifying Conditions
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html)
	// in the Amazon DynamoDB Developer Guide.
	ExpressionAttributeValues map[string]*types.AttributeValue
	// A string that identifies one or more attributes to retrieve from the table.
	// These attributes can include scalars, sets, or elements of a JSON document. The
	// attributes in the expression must be separated by commas. If no attribute names
	// are specified, then all attributes will be returned. If any of the requested
	// attributes are not found, they will not appear in the result. For more
	// information, see Accessing Item Attributes
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html)
	// in the Amazon DynamoDB Developer Guide.
	ProjectionExpression *string
	// Determines the read consistency model: If set to true, then the operation uses
	// strongly consistent reads; otherwise, the operation uses eventually consistent
	// reads. Strongly consistent reads are not supported on global secondary indexes.
	// If you query a global secondary index with ConsistentRead set to true, you will
	// receive a ValidationException.
	ConsistentRead *bool
	// This is a legacy parameter. Use FilterExpression instead. For more information,
	// see ConditionalOperator
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html)
	// in the Amazon DynamoDB Developer Guide.
	ConditionalOperator types.ConditionalOperator
	// The attributes to be returned in the result. You can retrieve all item
	// attributes, specific item attributes, the count of matching items, or in the
	// case of an index, some or all of the attributes projected into the index.
	//
	//     *
	// ALL_ATTRIBUTES - Returns all of the item attributes from the specified table or
	// index. If you query a local secondary index, then for each matching item in the
	// index, DynamoDB fetches the entire item from the parent table. If the index is
	// configured to project all item attributes, then all of the data can be obtained
	// from the local secondary index, and no fetching is required.
	//
	//     *
	// ALL_PROJECTED_ATTRIBUTES - Allowed only when querying an index. Retrieves all
	// attributes that have been projected into the index. If the index is configured
	// to project all attributes, this return value is equivalent to specifying
	// ALL_ATTRIBUTES.
	//
	//     * COUNT - Returns the number of matching items, rather than
	// the matching items themselves.
	//
	//     * SPECIFIC_ATTRIBUTES - Returns only the
	// attributes listed in AttributesToGet. This return value is equivalent to
	// specifying AttributesToGet without specifying any value for Select. If you query
	// or scan a local secondary index and request only attributes that are projected
	// into that index, the operation will read only the index and not the table. If
	// any of the requested attributes are not projected into the local secondary
	// index, DynamoDB fetches each of these attributes from the parent table. This
	// extra fetching incurs additional throughput cost and latency. If you query or
	// scan a global secondary index, you can only request attributes that are
	// projected into the index. Global secondary index queries cannot fetch attributes
	// from the parent table.
	//
	// If neither Select nor AttributesToGet are specified,
	// DynamoDB defaults to ALL_ATTRIBUTES when accessing a table, and
	// ALL_PROJECTED_ATTRIBUTES when accessing an index. You cannot use both Select and
	// AttributesToGet together in a single request, unless the value for Select is
	// SPECIFIC_ATTRIBUTES. (This usage is equivalent to specifying AttributesToGet
	// without any value for Select.) If you use the ProjectionExpression parameter,
	// then the value for Select can only be SPECIFIC_ATTRIBUTES. Any other value for
	// Select will return an error.
	Select types.Select
	// The maximum number of items to evaluate (not necessarily the number of matching
	// items). If DynamoDB processes the number of items up to the limit while
	// processing the results, it stops the operation and returns the matching values
	// up to that point, and a key in LastEvaluatedKey to apply in a subsequent
	// operation, so that you can pick up where you left off. Also, if the processed
	// dataset size exceeds 1 MB before DynamoDB reaches this limit, it stops the
	// operation and returns the matching values up to the limit, and a key in
	// LastEvaluatedKey to apply in a subsequent operation to continue the operation.
	// For more information, see Query and Scan
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html)
	// in the Amazon DynamoDB Developer Guide.
	Limit *int32
	// A string that contains conditions that DynamoDB applies after the Query
	// operation, but before the data is returned to you. Items that do not satisfy the
	// FilterExpression criteria are not returned. A FilterExpression does not allow
	// key attributes. You cannot define a filter expression based on a partition key
	// or a sort key. A FilterExpression is applied after the items have already been
	// read; the process of filtering does not consume any additional read capacity
	// units. For more information, see Filter Expressions
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#FilteringResults)
	// in the Amazon DynamoDB Developer Guide.
	FilterExpression *string
	// The primary key of the first item that this operation will evaluate. Use the
	// value that was returned for LastEvaluatedKey in the previous operation. The data
	// type for ExclusiveStartKey must be String, Number, or Binary. No set data types
	// are allowed.
	ExclusiveStartKey map[string]*types.AttributeValue
	// The condition that specifies the key values for items to be retrieved by the
	// Query action.  <p>The condition must perform an equality test on a single
	// partition key value.</p> <p>The condition can optionally perform one of several
	// comparison tests on a single sort key value. This allows <code>Query</code> to
	// retrieve one item with a given partition key value and sort key value, or
	// several items that have the same partition key value but different sort key
	// values.</p> <p>The partition key equality test is required, and must be
	// specified in the following format:</p> <p> <code>partitionKeyName</code>
	// <i>=</i> <code>:partitionkeyval</code> </p> <p>If you also want to provide a
	// condition for the sort key, it must be combined using <code>AND</code> with the
	// condition for the sort key. Following is an example, using the <b>=</b>
	// comparison operator for the sort key:</p> <p> <code>partitionKeyName</code>
	// <code>=</code> <code>:partitionkeyval</code> <code>AND</code>
	// <code>sortKeyName</code> <code>=</code> <code>:sortkeyval</code> </p> <p>Valid
	// comparisons for the sort key condition are as follows:</p> <ul> <li> <p>
	// <code>sortKeyName</code> <code>=</code> <code>:sortkeyval</code> - true if the
	// sort key value is equal to <code>:sortkeyval</code>.</p> </li> <li> <p>
	// <code>sortKeyName</code> <code><</code> <code>:sortkeyval</code> - true if the
	// sort key value is less than <code>:sortkeyval</code>.</p> </li> <li> <p>
	// <code>sortKeyName</code> <code><=</code> <code>:sortkeyval</code> - true if the
	// sort key value is less than or equal to <code>:sortkeyval</code>.</p> </li> <li>
	// <p> <code>sortKeyName</code> <code>></code> <code>:sortkeyval</code> - true if
	// the sort key value is greater than <code>:sortkeyval</code>.</p> </li> <li> <p>
	// <code>sortKeyName</code> <code>>= </code> <code>:sortkeyval</code> - true if the
	// sort key value is greater than or equal to <code>:sortkeyval</code>.</p> </li>
	// <li> <p> <code>sortKeyName</code> <code>BETWEEN</code> <code>:sortkeyval1</code>
	// <code>AND</code> <code>:sortkeyval2</code> - true if the sort key value is
	// greater than or equal to <code>:sortkeyval1</code>, and less than or equal to
	// <code>:sortkeyval2</code>.</p> </li> <li> <p> <code>begins_with (</code>
	// <code>sortKeyName</code>, <code>:sortkeyval</code> <code>)</code> - true if the
	// sort key value begins with a particular operand. (You cannot use this function
	// with a sort key that is of type Number.) Note that the function name
	// <code>begins_with</code> is case-sensitive.</p> </li> </ul> <p>Use the
	// <code>ExpressionAttributeValues</code> parameter to replace tokens such as
	// <code>:partitionval</code> and <code>:sortval</code> with actual values at
	// runtime.</p> <p>You can optionally use the <code>ExpressionAttributeNames</code>
	// parameter to replace the names of the partition key and sort key with
	// placeholder tokens. This option might be necessary if an attribute name
	// conflicts with a DynamoDB reserved word. For example, the following
	// <code>KeyConditionExpression</code> parameter causes an error because
	// <i>Size</i> is a reserved word:</p> <ul> <li> <p> <code>Size = :myval</code>
	// </p> </li> </ul> <p>To work around this, define a placeholder (such a
	// <code>#S</code>) to represent the attribute name <i>Size</i>.
	// <code>KeyConditionExpression</code> then is as follows:</p> <ul> <li> <p>
	// <code>#S = :myval</code> </p> </li> </ul> <p>For a list of reserved words, see
	// <a
	// href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html">Reserved
	// Words</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> <p>For more
	// information on <code>ExpressionAttributeNames</code> and
	// <code>ExpressionAttributeValues</code>, see <a
	// href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ExpressionPlaceholders.html">Using
	// Placeholders for Attribute Names and Values</a> in the <i>Amazon DynamoDB
	// Developer Guide</i>.</p>
	KeyConditionExpression *string
}

type QueryOutput struct {
	// The number of items evaluated, before any QueryFilter is applied. A high
	// ScannedCount value with few, or no, Count results indicates an inefficient Query
	// operation. For more information, see Count and ScannedCount
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#Count)
	// in the Amazon DynamoDB Developer Guide. If you did not use a filter in the
	// request, then ScannedCount is the same as Count.
	ScannedCount *int32
	// The number of items in the response. If you used a QueryFilter in the request,
	// then Count is the number of items returned after the filter was applied, and
	// ScannedCount is the number of matching items before the filter was applied. If
	// you did not use a filter in the request, then Count and ScannedCount are the
	// same.
	Count *int32
	// An array of item attributes that match the query criteria. Each element in this
	// array consists of an attribute name and the value for that attribute.
	Items []map[string]*types.AttributeValue
	// The capacity units consumed by the Query operation. The data returned includes
	// the total provisioned throughput consumed, along with statistics for the table
	// and any indexes involved in the operation. ConsumedCapacity is only returned if
	// the ReturnConsumedCapacity parameter was specified. For more information, see
	// Provisioned Throughput
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html)
	// in the Amazon DynamoDB Developer Guide.
	ConsumedCapacity *types.ConsumedCapacity
	// The primary key of the item where the operation stopped, inclusive of the
	// previous result set. Use this value to start a new operation, excluding this
	// value in the new request. If LastEvaluatedKey is empty, then the "last page" of
	// results has been processed and there is no more data to be retrieved. If
	// LastEvaluatedKey is not empty, it does not necessarily mean that there is more
	// data in the result set. The only way to know when you have reached the end of
	// the result set is when LastEvaluatedKey is empty.
	LastEvaluatedKey map[string]*types.AttributeValue

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  ResolverOptions
}

type ResolveEndpointMiddlewareOptions interface {
	GetEndpointResolver() EndpointResolver
	GetEndpointOptions() ResolverOptions
}

type ResolverOptions = internalendpoints.Options

type RestoreTableFromBackupInput struct {
	// List of global secondary indexes for the restored table. The indexes provided
	// should match existing secondary indexes. You can choose to exclude some or all
	// of the indexes at the time of restore.
	GlobalSecondaryIndexOverride []*types.GlobalSecondaryIndex
	// The new server-side encryption settings for the restored table.
	SSESpecificationOverride *types.SSESpecification
	// The name of the new table to which the backup must be restored.
	TargetTableName *string
	// The Amazon Resource Name (ARN) associated with the backup.
	BackupArn *string
	// List of local secondary indexes for the restored table. The indexes provided
	// should match existing secondary indexes. You can choose to exclude some or all
	// of the indexes at the time of restore.
	LocalSecondaryIndexOverride []*types.LocalSecondaryIndex
	// The billing mode of the restored table.
	BillingModeOverride types.BillingMode
	// Provisioned throughput settings for the restored table.
	ProvisionedThroughputOverride *types.ProvisionedThroughput
}

type RestoreTableFromBackupOutput struct {
	// The description of the table created from an existing backup.
	TableDescription *types.TableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type RestoreTableToPointInTimeInput struct {
	// List of local secondary indexes for the restored table. The indexes provided
	// should match existing secondary indexes. You can choose to exclude some or all
	// of the indexes at the time of restore.
	LocalSecondaryIndexOverride []*types.LocalSecondaryIndex
	// The DynamoDB table that will be restored. This value is an Amazon Resource Name
	// (ARN).
	SourceTableArn *string
	// Provisioned throughput settings for the restored table.
	ProvisionedThroughputOverride *types.ProvisionedThroughput
	// The new server-side encryption settings for the restored table.
	SSESpecificationOverride *types.SSESpecification
	// The name of the new table to which it must be restored to.
	TargetTableName *string
	// The billing mode of the restored table.
	BillingModeOverride types.BillingMode
	// Name of the source table that is being restored.
	SourceTableName *string
	// Time in the past to restore the table to.
	RestoreDateTime *time.Time
	// List of global secondary indexes for the restored table. The indexes provided
	// should match existing secondary indexes. You can choose to exclude some or all
	// of the indexes at the time of restore.
	GlobalSecondaryIndexOverride []*types.GlobalSecondaryIndex
	// Restore the table to the latest possible time. LatestRestorableDateTime is
	// typically 5 minutes before the current time.
	UseLatestRestorableTime *bool
}

type RestoreTableToPointInTimeOutput struct {
	// Represents the properties of a table.
	TableDescription *types.TableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ScanInput struct {
	// One or more values that can be substituted in an expression. Use the : (colon)
	// character in an expression to dereference an attribute value. For example,
	// suppose that you wanted to check whether the value of the ProductStatus
	// attribute was one of the following: Available | Backordered | Discontinued You
	// would first need to specify ExpressionAttributeValues as follows: {
	// ":avail":{"S":"Available"}, ":back":{"S":"Backordered"},
	// ":disc":{"S":"Discontinued"} } You could then use these values in an expression,
	// such as this: ProductStatus IN (:avail, :back, :disc) For more information on
	// expression attribute values, see Condition Expressions
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html)
	// in the Amazon DynamoDB Developer Guide.
	ExpressionAttributeValues map[string]*types.AttributeValue
	// The attributes to be returned in the result. You can retrieve all item
	// attributes, specific item attributes, the count of matching items, or in the
	// case of an index, some or all of the attributes projected into the index.
	//
	//     *
	// ALL_ATTRIBUTES - Returns all of the item attributes from the specified table or
	// index. If you query a local secondary index, then for each matching item in the
	// index, DynamoDB fetches the entire item from the parent table. If the index is
	// configured to project all item attributes, then all of the data can be obtained
	// from the local secondary index, and no fetching is required.
	//
	//     *
	// ALL_PROJECTED_ATTRIBUTES - Allowed only when querying an index. Retrieves all
	// attributes that have been projected into the index. If the index is configured
	// to project all attributes, this return value is equivalent to specifying
	// ALL_ATTRIBUTES.
	//
	//     * COUNT - Returns the number of matching items, rather than
	// the matching items themselves.
	//
	//     * SPECIFIC_ATTRIBUTES - Returns only the
	// attributes listed in AttributesToGet. This return value is equivalent to
	// specifying AttributesToGet without specifying any value for Select. If you query
	// or scan a local secondary index and request only attributes that are projected
	// into that index, the operation reads only the index and not the table. If any of
	// the requested attributes are not projected into the local secondary index,
	// DynamoDB fetches each of these attributes from the parent table. This extra
	// fetching incurs additional throughput cost and latency. If you query or scan a
	// global secondary index, you can only request attributes that are projected into
	// the index. Global secondary index queries cannot fetch attributes from the
	// parent table.
	//
	// If neither Select nor AttributesToGet are specified, DynamoDB
	// defaults to ALL_ATTRIBUTES when accessing a table, and ALL_PROJECTED_ATTRIBUTES
	// when accessing an index. You cannot use both Select and AttributesToGet together
	// in a single request, unless the value for Select is SPECIFIC_ATTRIBUTES. (This
	// usage is equivalent to specifying AttributesToGet without any value for Select.)
	// If you use the ProjectionExpression parameter, then the value for Select can
	// only be SPECIFIC_ATTRIBUTES. Any other value for Select will return an error.
	Select types.Select
	// For a parallel Scan request, Segment identifies an individual segment to be
	// scanned by an application worker. Segment IDs are zero-based, so the first
	// segment is always 0. For example, if you want to use four application threads to
	// scan a table or an index, then the first thread specifies a Segment value of 0,
	// the second thread specifies 1, and so on. The value of LastEvaluatedKey returned
	// from a parallel Scan request must be used as ExclusiveStartKey with the same
	// segment ID in a subsequent Scan operation. The value for Segment must be greater
	// than or equal to 0, and less than the value provided for TotalSegments. If you
	// provide Segment, you must also provide TotalSegments.
	Segment *int32
	// For a parallel Scan request, TotalSegments represents the total number of
	// segments into which the Scan operation will be divided. The value of
	// TotalSegments corresponds to the number of application workers that will perform
	// the parallel scan. For example, if you want to use four application threads to
	// scan a table or an index, specify a TotalSegments value of 4. The value for
	// TotalSegments must be greater than or equal to 1, and less than or equal to
	// 1000000. If you specify a TotalSegments value of 1, the Scan operation will be
	// sequential rather than parallel. If you specify TotalSegments, you must also
	// specify Segment.
	TotalSegments *int32
	// A Boolean value that determines the read consistency model during the scan:
	//
	//
	// * If ConsistentRead is false, then the data returned from Scan might not contain
	// the results from other recently completed write operations (PutItem, UpdateItem,
	// or DeleteItem).
	//
	//     * If ConsistentRead is true, then all of the write
	// operations that completed before the Scan began are guaranteed to be contained
	// in the Scan response.
	//
	// The default setting for ConsistentRead is false. The
	// ConsistentRead parameter is not supported on global secondary indexes. If you
	// scan a global secondary index with ConsistentRead set to true, you will receive
	// a ValidationException.
	ConsistentRead *bool
	// A string that identifies one or more attributes to retrieve from the specified
	// table or index. These attributes can include scalars, sets, or elements of a
	// JSON document. The attributes in the expression must be separated by commas. If
	// no attribute names are specified, then all attributes will be returned. If any
	// of the requested attributes are not found, they will not appear in the result.
	// For more information, see Specifying Item Attributes
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html)
	// in the Amazon DynamoDB Developer Guide.
	ProjectionExpression *string
	// This is a legacy parameter. Use FilterExpression instead. For more information,
	// see ScanFilter
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ScanFilter.html)
	// in the Amazon DynamoDB Developer Guide.
	ScanFilter map[string]*types.Condition
	// The name of a secondary index to scan. This index can be any local secondary
	// index or global secondary index. Note that if you use the IndexName parameter,
	// you must also provide TableName.
	IndexName *string
	// Determines the level of detail about provisioned throughput consumption that is
	// returned in the response:
	//
	//     * INDEXES - The response includes the aggregate
	// ConsumedCapacity for the operation, together with ConsumedCapacity for each
	// table and secondary index that was accessed. Note that some operations, such as
	// GetItem and BatchGetItem, do not access any indexes at all. In these cases,
	// specifying INDEXES will only return ConsumedCapacity information for table(s).
	//
	//
	// * TOTAL - The response includes only the aggregate ConsumedCapacity for the
	// operation.
	//
	//     * NONE - No ConsumedCapacity details are included in the
	// response.
	ReturnConsumedCapacity types.ReturnConsumedCapacity
	// The name of the table containing the requested items; or, if you provide
	// IndexName, the name of the table to which that index belongs.
	TableName *string
	// This is a legacy parameter. Use ProjectionExpression instead. For more
	// information, see AttributesToGet
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html)
	// in the Amazon DynamoDB Developer Guide.
	AttributesToGet []*string
	// One or more substitution tokens for attribute names in an expression. The
	// following are some use cases for using ExpressionAttributeNames:
	//
	//     * To
	// access an attribute whose name conflicts with a DynamoDB reserved word.
	//
	//     *
	// To create a placeholder for repeating occurrences of an attribute name in an
	// expression.
	//
	//     * To prevent special characters in an attribute name from being
	// misinterpreted in an expression.
	//
	// Use the # character in an expression to
	// dereference an attribute name. For example, consider the following attribute
	// name:
	//
	//     * Percentile
	//
	// The name of this attribute conflicts with a reserved
	// word, so it cannot be used directly in an expression. (For the complete list of
	// reserved words, see Reserved Words
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html)
	// in the Amazon DynamoDB Developer Guide). To work around this, you could specify
	// the following for ExpressionAttributeNames:
	//
	//     * {"#P":"Percentile"}
	//
	// You
	// could then use this substitution in an expression, as in this example:
	//
	//     * #P
	// = :val
	//
	// Tokens that begin with the : character are expression attribute values,
	// which are placeholders for the actual value at runtime. For more information on
	// expression attribute names, see Specifying Item Attributes
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html)
	// in the Amazon DynamoDB Developer Guide.
	ExpressionAttributeNames map[string]*string
	// A string that contains conditions that DynamoDB applies after the Scan
	// operation, but before the data is returned to you. Items that do not satisfy the
	// FilterExpression criteria are not returned. A FilterExpression is applied after
	// the items have already been read; the process of filtering does not consume any
	// additional read capacity units. For more information, see Filter Expressions
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#FilteringResults)
	// in the Amazon DynamoDB Developer Guide.
	FilterExpression *string
	// The primary key of the first item that this operation will evaluate. Use the
	// value that was returned for LastEvaluatedKey in the previous operation. The data
	// type for ExclusiveStartKey must be String, Number or Binary. No set data types
	// are allowed. In a parallel scan, a Scan request that includes ExclusiveStartKey
	// must specify the same segment whose previous Scan returned the corresponding
	// value of LastEvaluatedKey.
	ExclusiveStartKey map[string]*types.AttributeValue
	// This is a legacy parameter. Use FilterExpression instead. For more information,
	// see ConditionalOperator
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html)
	// in the Amazon DynamoDB Developer Guide.
	ConditionalOperator types.ConditionalOperator
	// The maximum number of items to evaluate (not necessarily the number of matching
	// items). If DynamoDB processes the number of items up to the limit while
	// processing the results, it stops the operation and returns the matching values
	// up to that point, and a key in LastEvaluatedKey to apply in a subsequent
	// operation, so that you can pick up where you left off. Also, if the processed
	// dataset size exceeds 1 MB before DynamoDB reaches this limit, it stops the
	// operation and returns the matching values up to the limit, and a key in
	// LastEvaluatedKey to apply in a subsequent operation to continue the operation.
	// For more information, see Working with Queries
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html)
	// in the Amazon DynamoDB Developer Guide.
	Limit *int32
}

type ScanOutput struct {
	// An array of item attributes that match the scan criteria. Each element in this
	// array consists of an attribute name and the value for that attribute.
	Items []map[string]*types.AttributeValue
	// The number of items in the response. If you set ScanFilter in the request, then
	// Count is the number of items returned after the filter was applied, and
	// ScannedCount is the number of matching items before the filter was applied. If
	// you did not use a filter in the request, then Count is the same as ScannedCount.
	Count *int32
	// The number of items evaluated, before any ScanFilter is applied. A high
	// ScannedCount value with few, or no, Count results indicates an inefficient Scan
	// operation. For more information, see Count and ScannedCount
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#Count)
	// in the Amazon DynamoDB Developer Guide. If you did not use a filter in the
	// request, then ScannedCount is the same as Count.
	ScannedCount *int32
	// The primary key of the item where the operation stopped, inclusive of the
	// previous result set. Use this value to start a new operation, excluding this
	// value in the new request. If LastEvaluatedKey is empty, then the "last page" of
	// results has been processed and there is no more data to be retrieved. If
	// LastEvaluatedKey is not empty, it does not necessarily mean that there is more
	// data in the result set. The only way to know when you have reached the end of
	// the result set is when LastEvaluatedKey is empty.
	LastEvaluatedKey map[string]*types.AttributeValue
	// The capacity units consumed by the Scan operation. The data returned includes
	// the total provisioned throughput consumed, along with statistics for the table
	// and any indexes involved in the operation. ConsumedCapacity is only returned if
	// the ReturnConsumedCapacity parameter was specified. For more information, see
	// Provisioned Throughput
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html)
	// in the Amazon DynamoDB Developer Guide.
	ConsumedCapacity *types.ConsumedCapacity

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type TagResourceInput struct {
	// The tags to be assigned to the Amazon DynamoDB resource.
	Tags []*types.Tag
	// Identifies the Amazon DynamoDB resource to which tags should be added. This
	// value is an Amazon Resource Name (ARN).
	ResourceArn *string
}

type TagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type TransactGetItemsInput struct {
	// An ordered array of up to 25 TransactGetItem objects, each of which contains a
	// Get structure.
	TransactItems []*types.TransactGetItem
	// A value of TOTAL causes consumed capacity information to be returned, and a
	// value of NONE prevents that information from being returned. No other value is
	// valid.
	ReturnConsumedCapacity types.ReturnConsumedCapacity
}

type TransactGetItemsOutput struct {
	// If the ReturnConsumedCapacity value was TOTAL, this is an array of
	// ConsumedCapacity objects, one for each table addressed by TransactGetItem
	// objects in the TransactItems parameter. These ConsumedCapacity objects report
	// the read-capacity units consumed by the TransactGetItems call in that table.
	ConsumedCapacity []*types.ConsumedCapacity
	// An ordered array of up to 25 ItemResponse objects, each of which corresponds to
	// the TransactGetItem object in the same position in the TransactItems array. Each
	// ItemResponse object contains a Map of the name-value pairs that are the
	// projected attributes of the requested item. If a requested item could not be
	// retrieved, the corresponding ItemResponse object is Null, or if the requested
	// item has no projected attributes, the corresponding ItemResponse object is an
	// empty Map.
	Responses []*types.ItemResponse

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type TransactWriteItemsInput struct {
	// An ordered array of up to 25 TransactWriteItem objects, each of which contains a
	// ConditionCheck, Put, Update, or Delete object. These can operate on items in
	// different tables, but the tables must reside in the same AWS account and Region,
	// and no two of them can operate on the same item.
	TransactItems []*types.TransactWriteItem
	// Providing a ClientRequestToken makes the call to TransactWriteItems idempotent,
	// meaning that multiple identical calls have the same effect as one single call.
	// Although multiple identical calls using the same client request token produce
	// the same result on the server (no side effects), the responses to the calls
	// might not be the same. If the ReturnConsumedCapacity> parameter is set, then the
	// initial TransactWriteItems call returns the amount of write capacity units
	// consumed in making the changes. Subsequent TransactWriteItems calls with the
	// same client token return the number of read capacity units consumed in reading
	// the item. A client request token is valid for 10 minutes after the first request
	// that uses it is completed. After 10 minutes, any request with the same client
	// token is treated as a new request. Do not resubmit the same request with the
	// same client token for more than 10 minutes, or the result might not be
	// idempotent. If you submit a request with the same client token but a change in
	// other parameters within the 10-minute idempotency window, DynamoDB returns an
	// IdempotentParameterMismatch exception.
	ClientRequestToken *string
	// Determines the level of detail about provisioned throughput consumption that is
	// returned in the response:
	//
	//     * INDEXES - The response includes the aggregate
	// ConsumedCapacity for the operation, together with ConsumedCapacity for each
	// table and secondary index that was accessed. Note that some operations, such as
	// GetItem and BatchGetItem, do not access any indexes at all. In these cases,
	// specifying INDEXES will only return ConsumedCapacity information for table(s).
	//
	//
	// * TOTAL - The response includes only the aggregate ConsumedCapacity for the
	// operation.
	//
	//     * NONE - No ConsumedCapacity details are included in the
	// response.
	ReturnConsumedCapacity types.ReturnConsumedCapacity
	// Determines whether item collection metrics are returned. If set to SIZE, the
	// response includes statistics about item collections (if any), that were modified
	// during the operation and are returned in the response. If set to NONE (the
	// default), no statistics are returned.
	ReturnItemCollectionMetrics types.ReturnItemCollectionMetrics
}

type TransactWriteItemsOutput struct {
	// The capacity units consumed by the entire TransactWriteItems operation. The
	// values of the list are ordered according to the ordering of the TransactItems
	// request parameter.
	ConsumedCapacity []*types.ConsumedCapacity
	// A list of tables that were processed by TransactWriteItems and, for each table,
	// information about any item collections that were affected by individual
	// UpdateItem, PutItem, or DeleteItem operations.
	ItemCollectionMetrics map[string][]*types.ItemCollectionMetrics

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UntagResourceInput struct {
	// The DynamoDB resource that the tags will be removed from. This value is an
	// Amazon Resource Name (ARN).
	ResourceArn *string
	// A list of tag keys. Existing tags of the resource whose keys are members of this
	// list will be removed from the DynamoDB resource.
	TagKeys []*string
}

type UntagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateContinuousBackupsInput struct {
	// The name of the table.
	TableName *string
	// Represents the settings used to enable point in time recovery.
	PointInTimeRecoverySpecification *types.PointInTimeRecoverySpecification
}

type UpdateContinuousBackupsOutput struct {
	// Represents the continuous backups and point in time recovery settings on the
	// table.
	ContinuousBackupsDescription *types.ContinuousBackupsDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateContributorInsightsInput struct {
	// Represents the contributor insights action.
	ContributorInsightsAction types.ContributorInsightsAction
	// The name of the table.
	TableName *string
	// The global secondary index name, if applicable.
	IndexName *string
}

type UpdateContributorInsightsOutput struct {
	// The status of contributor insights
	ContributorInsightsStatus types.ContributorInsightsStatus
	// The name of the table.
	TableName *string
	// The name of the global secondary index, if applicable.
	IndexName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateGlobalTableInput struct {
	// The global table name.
	GlobalTableName *string
	// A list of Regions that should be added or removed from the global table.
	ReplicaUpdates []*types.ReplicaUpdate
}

type UpdateGlobalTableOutput struct {
	// Contains the details of the global table.
	GlobalTableDescription *types.GlobalTableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateGlobalTableSettingsInput struct {
	// Represents the settings of a global secondary index for a global table that will
	// be modified.
	GlobalTableGlobalSecondaryIndexSettingsUpdate []*types.GlobalTableGlobalSecondaryIndexSettingsUpdate
	// Represents the settings for a global table in a Region that will be modified.
	ReplicaSettingsUpdate []*types.ReplicaSettingsUpdate
	// Auto scaling settings for managing provisioned write capacity for the global
	// table.
	GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate *types.AutoScalingSettingsUpdate
	// The billing mode of the global table. If GlobalTableBillingMode is not
	// specified, the global table defaults to PROVISIONED capacity billing mode.
	//
	//
	// * PROVISIONED - We recommend using PROVISIONED for predictable workloads.
	// PROVISIONED sets the billing mode to Provisioned Mode
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.ProvisionedThroughput.Manual).
	//
	//
	// * PAY_PER_REQUEST - We recommend using PAY_PER_REQUEST for unpredictable
	// workloads. PAY_PER_REQUEST sets the billing mode to On-Demand Mode
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.OnDemand).
	GlobalTableBillingMode types.BillingMode
	// The name of the global table
	GlobalTableName *string
	// The maximum number of writes consumed per second before DynamoDB returns a
	// ThrottlingException.
	GlobalTableProvisionedWriteCapacityUnits *int64
}

type UpdateGlobalTableSettingsOutput struct {
	// The Region-specific settings for the global table.
	ReplicaSettings []*types.ReplicaSettingsDescription
	// The name of the global table.
	GlobalTableName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateItemInput struct {
	// Determines whether item collection metrics are returned. If set to SIZE, the
	// response includes statistics about item collections, if any, that were modified
	// during the operation are returned in the response. If set to NONE (the default),
	// no statistics are returned.
	ReturnItemCollectionMetrics types.ReturnItemCollectionMetrics
	// Use ReturnValues if you want to get the item attributes as they appear before or
	// after they are updated. For UpdateItem, the valid values are:
	//
	//     * NONE - If
	// ReturnValues is not specified, or if its value is NONE, then nothing is
	// returned. (This setting is the default for ReturnValues.)
	//
	//     * ALL_OLD -
	// Returns all of the attributes of the item, as they appeared before the
	// UpdateItem operation.
	//
	//     * UPDATED_OLD - Returns only the updated attributes,
	// as they appeared before the UpdateItem operation.
	//
	//     * ALL_NEW - Returns all
	// of the attributes of the item, as they appear after the UpdateItem operation.
	//
	//
	// * UPDATED_NEW - Returns only the updated attributes, as they appear after the
	// UpdateItem operation.
	//
	// There is no additional cost associated with requesting a
	// return value aside from the small network and processing overhead of receiving a
	// larger response. No read capacity units are consumed. The values returned are
	// strongly consistent.
	ReturnValues types.ReturnValue
	// One or more substitution tokens for attribute names in an expression. The
	// following are some use cases for using ExpressionAttributeNames:
	//
	//     * To
	// access an attribute whose name conflicts with a DynamoDB reserved word.
	//
	//     *
	// To create a placeholder for repeating occurrences of an attribute name in an
	// expression.
	//
	//     * To prevent special characters in an attribute name from being
	// misinterpreted in an expression.
	//
	// Use the # character in an expression to
	// dereference an attribute name. For example, consider the following attribute
	// name:
	//
	//     * Percentile
	//
	// The name of this attribute conflicts with a reserved
	// word, so it cannot be used directly in an expression. (For the complete list of
	// reserved words, see Reserved Words
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html)
	// in the Amazon DynamoDB Developer Guide.) To work around this, you could specify
	// the following for ExpressionAttributeNames:
	//
	//     * {"#P":"Percentile"}
	//
	// You
	// could then use this substitution in an expression, as in this example:
	//
	//     * #P
	// = :val
	//
	// Tokens that begin with the : character are expression attribute values,
	// which are placeholders for the actual value at runtime. For more information
	// about expression attribute names, see Specifying Item Attributes
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html)
	// in the Amazon DynamoDB Developer Guide.
	ExpressionAttributeNames map[string]*string
	// An expression that defines one or more attributes to be updated, the action to
	// be performed on them, and new values for them. The following action values are
	// available for UpdateExpression.
	//
	//     * SET - Adds one or more attributes and
	// values to an item. If any of these attributes already exist, they are replaced
	// by the new values. You can also use SET to add or subtract from an attribute
	// that is of type Number. For example: SET myNum = myNum + :valSET supports the
	// following functions:
	//
	//         * if_not_exists (path, operand) - if the item does
	// not contain an attribute at the specified path, then if_not_exists evaluates to
	// operand; otherwise, it evaluates to path. You can use this function to avoid
	// overwriting an attribute that may already be present in the item.
	//
	//         *
	// list_append (operand, operand) - evaluates to a list with a new element added to
	// it. You can append the new element to the start or the end of the list by
	// reversing the order of the operands.
	//
	//     These function names are
	// case-sensitive.
	//
	//     * REMOVE - Removes one or more attributes from an item.
	//
	//
	// * ADD - Adds the specified value to the item, if the attribute does not already
	// exist. If the attribute does exist, then the behavior of ADD depends on the data
	// type of the attribute:
	//
	//         * If the existing attribute is a number, and if
	// Value is also a number, then Value is mathematically added to the existing
	// attribute. If Value is a negative number, then it is subtracted from the
	// existing attribute. If you use ADD to increment or decrement a number value for
	// an item that doesn't exist before the update, DynamoDB uses 0 as the initial
	// value. Similarly, if you use ADD for an existing item to increment or decrement
	// an attribute value that doesn't exist before the update, DynamoDB uses 0 as the
	// initial value. For example, suppose that the item you want to update doesn't
	// have an attribute named itemcount, but you decide to ADD the number 3 to this
	// attribute anyway. DynamoDB will create the itemcount attribute, set its initial
	// value to 0, and finally add 3 to it. The result will be a new itemcount
	// attribute in the item, with a value of 3.
	//
	//         * If the existing data type
	// is a set and if Value is also a set, then Value is added to the existing set.
	// For example, if the attribute value is the set [1,2], and the ADD action
	// specified [3], then the final attribute value is [1,2,3]. An error occurs if an
	// ADD action is specified for a set attribute and the attribute type specified
	// does not match the existing set type. Both sets must have the same primitive
	// data type. For example, if the existing data type is a set of strings, the Value
	// must also be a set of strings.
	//
	//     The ADD action only supports Number and set
	// data types. In addition, ADD can only be used on top-level attributes, not
	// nested attributes.
	//
	//     * DELETE - Deletes an element from a set. If a set of
	// values is specified, then those values are subtracted from the old set. For
	// example, if the attribute value was the set [a,b,c] and the DELETE action
	// specifies [a,c], then the final attribute value is [b]. Specifying an empty set
	// is an error. The DELETE action only supports set data types. In addition, DELETE
	// can only be used on top-level attributes, not nested attributes.  </li> </ul>
	// <p>You can have many actions in a single expression, such as the following:
	// <code>SET a=:value1, b=:value2 DELETE :value3, :value4, :value5</code> </p>
	// <p>For more information on update expressions, see <a
	// href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.Modifying.html">Modifying
	// Items and Attributes</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p>
	UpdateExpression *string
	// A condition that must be satisfied in order for a conditional update to succeed.
	// An expression can contain any of the following:
	//
	//     * Functions:
	// attribute_exists | attribute_not_exists | attribute_type | contains |
	// begins_with | size These function names are case-sensitive.
	//
	//     * Comparison
	// operators: = | <> | < | > | <= | >= | BETWEEN | IN
	//
	//     * Logical operators: AND
	// | OR | NOT
	//
	// For more information about condition expressions, see Specifying
	// Conditions
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html)
	// in the Amazon DynamoDB Developer Guide.
	ConditionExpression *string
	// This is a legacy parameter. Use ConditionExpression instead. For more
	// information, see ConditionalOperator
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html)
	// in the Amazon DynamoDB Developer Guide.
	ConditionalOperator types.ConditionalOperator
	// One or more values that can be substituted in an expression. Use the : (colon)
	// character in an expression to dereference an attribute value. For example,
	// suppose that you wanted to check whether the value of the ProductStatus
	// attribute was one of the following: Available | Backordered | Discontinued You
	// would first need to specify ExpressionAttributeValues as follows: {
	// ":avail":{"S":"Available"}, ":back":{"S":"Backordered"},
	// ":disc":{"S":"Discontinued"} } You could then use these values in an expression,
	// such as this: ProductStatus IN (:avail, :back, :disc) For more information on
	// expression attribute values, see Condition Expressions
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html)
	// in the Amazon DynamoDB Developer Guide.
	ExpressionAttributeValues map[string]*types.AttributeValue
	// Determines the level of detail about provisioned throughput consumption that is
	// returned in the response:
	//
	//     * INDEXES - The response includes the aggregate
	// ConsumedCapacity for the operation, together with ConsumedCapacity for each
	// table and secondary index that was accessed. Note that some operations, such as
	// GetItem and BatchGetItem, do not access any indexes at all. In these cases,
	// specifying INDEXES will only return ConsumedCapacity information for table(s).
	//
	//
	// * TOTAL - The response includes only the aggregate ConsumedCapacity for the
	// operation.
	//
	//     * NONE - No ConsumedCapacity details are included in the
	// response.
	ReturnConsumedCapacity types.ReturnConsumedCapacity
	// This is a legacy parameter. Use UpdateExpression instead. For more information,
	// see AttributeUpdates
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributeUpdates.html)
	// in the Amazon DynamoDB Developer Guide.
	AttributeUpdates map[string]*types.AttributeValueUpdate
	// The primary key of the item to be updated. Each element consists of an attribute
	// name and a value for that attribute. For the primary key, you must provide all
	// of the attributes. For example, with a simple primary key, you only need to
	// provide a value for the partition key. For a composite primary key, you must
	// provide values for both the partition key and the sort key.
	Key map[string]*types.AttributeValue
	// This is a legacy parameter. Use ConditionExpression instead. For more
	// information, see Expected
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.Expected.html)
	// in the Amazon DynamoDB Developer Guide.
	Expected map[string]*types.ExpectedAttributeValue
	// The name of the table containing the item to update.
	TableName *string
}

type UpdateItemOutput struct {
	// A map of attribute values as they appear before or after the UpdateItem
	// operation, as determined by the ReturnValues parameter. The Attributes map is
	// only present if ReturnValues was specified as something other than NONE in the
	// request. Each element represents one attribute.
	Attributes map[string]*types.AttributeValue
	// Information about item collections, if any, that were affected by the UpdateItem
	// operation. ItemCollectionMetrics is only returned if the
	// ReturnItemCollectionMetrics parameter was specified. If the table does not have
	// any local secondary indexes, this information is not returned in the response.
	// Each ItemCollectionMetrics element consists of:
	//
	//     * ItemCollectionKey - The
	// partition key value of the item collection. This is the same as the partition
	// key value of the item itself.
	//
	//     * SizeEstimateRangeGB - An estimate of item
	// collection size, in gigabytes. This value is a two-element array containing a
	// lower bound and an upper bound for the estimate. The estimate includes the size
	// of all the items in the table, plus the size of all attributes projected into
	// all of the local secondary indexes on that table. Use this estimate to measure
	// whether a local secondary index is approaching its size limit. The estimate is
	// subject to change over time; therefore, do not rely on the precision or accuracy
	// of the estimate.
	ItemCollectionMetrics *types.ItemCollectionMetrics
	// The capacity units consumed by the UpdateItem operation. The data returned
	// includes the total provisioned throughput consumed, along with statistics for
	// the table and any indexes involved in the operation. ConsumedCapacity is only
	// returned if the ReturnConsumedCapacity parameter was specified. For more
	// information, see Provisioned Throughput
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html)
	// in the Amazon DynamoDB Developer Guide.
	ConsumedCapacity *types.ConsumedCapacity

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateTableInput struct {
	// The new server-side encryption settings for the specified table.
	SSESpecification *types.SSESpecification
	// The name of the table to be updated.
	TableName *string
	// An array of attributes that describe the key schema for the table and indexes.
	// If you are adding a new global secondary index to the table,
	// AttributeDefinitions must include the key element(s) of the new index.
	AttributeDefinitions []*types.AttributeDefinition
	// An array of one or more global secondary indexes for the table. For each index
	// in the array, you can request one action:
	//
	//     * Create - add a new global
	// secondary index to the table.
	//
	//     * Update - modify the provisioned throughput
	// settings of an existing global secondary index.
	//
	//     * Delete - remove a global
	// secondary index from the table.
	//
	// You can create or delete only one global
	// secondary index per UpdateTable operation. For more information, see Managing
	// Global Secondary Indexes
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.OnlineOps.html)
	// in the Amazon DynamoDB Developer Guide.
	GlobalSecondaryIndexUpdates []*types.GlobalSecondaryIndexUpdate
	// Controls how you are charged for read and write throughput and how you manage
	// capacity. When switching from pay-per-request to provisioned capacity, initial
	// provisioned capacity values must be set. The initial provisioned capacity values
	// are estimated based on the consumed read and write capacity of your table and
	// global secondary indexes over the past 30 minutes.
	//
	//     * PROVISIONED - We
	// recommend using PROVISIONED for predictable workloads. PROVISIONED sets the
	// billing mode to Provisioned Mode
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.ProvisionedThroughput.Manual).
	//
	//
	// * PAY_PER_REQUEST - We recommend using PAY_PER_REQUEST for unpredictable
	// workloads. PAY_PER_REQUEST sets the billing mode to On-Demand Mode
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html#HowItWorks.OnDemand).
	BillingMode types.BillingMode
	// The new provisioned throughput settings for the specified table or index.
	ProvisionedThroughput *types.ProvisionedThroughput
	// A list of replica update actions (create, delete, or update) for the table. This
	// property only applies to Version 2019.11.21
	// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html)
	// of global tables.
	ReplicaUpdates []*types.ReplicationGroupUpdate
	// Represents the DynamoDB Streams configuration for the table. You receive a
	// ResourceInUseException if you try to enable a stream on a table that already has
	// a stream, or if you try to disable a stream on a table that doesn't have a
	// stream.
	StreamSpecification *types.StreamSpecification
}

type UpdateTableOutput struct {
	// Represents the properties of the table.
	TableDescription *types.TableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateTableReplicaAutoScalingInput struct {
	// Represents the auto scaling settings of replicas of the table that will be
	// modified.
	ReplicaUpdates []*types.ReplicaAutoScalingUpdate
	// Represents the auto scaling settings to be modified for a global table or global
	// secondary index.
	ProvisionedWriteCapacityAutoScalingUpdate *types.AutoScalingSettingsUpdate
	// The name of the global table to be updated.
	TableName *string
	// Represents the auto scaling settings of the global secondary indexes of the
	// replica to be updated.
	GlobalSecondaryIndexUpdates []*types.GlobalSecondaryIndexAutoScalingUpdate
}

type UpdateTableReplicaAutoScalingOutput struct {
	// Returns information about the auto scaling settings of a table with replicas.
	TableAutoScalingDescription *types.TableAutoScalingDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateTimeToLiveInput struct {
	// Represents the settings used to enable or disable Time to Live for the specified
	// table.
	TimeToLiveSpecification *types.TimeToLiveSpecification
	// The name of the table to be configured.
	TableName *string
}

type UpdateTimeToLiveOutput struct {
	// Represents the output of an UpdateTimeToLive operation.
	TimeToLiveSpecification *types.TimeToLiveSpecification

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}