dynamodb

type AuthResolverParameters struct {
	// The name of the operation being invoked.
	Operation string

	// The region in which the operation is being invoked.
	Region string
}

type AuthSchemeResolver interface {
	ResolveAuthSchemes(context.Context, *AuthResolverParameters) ([]*smithyauth.Option, error)
}

type BatchExecuteStatementInput struct {

	// The list of PartiQL statements representing the batch to run.
	//
	// This member is required.
	Statements []types.BatchStatementRequest

	// Determines the level of detail about either provisioned or on-demand 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
	// contains filtered or unexported fields
}

type BatchExecuteStatementOutput struct {

	// The capacity units consumed by the entire operation. The values of the list are
	// ordered according to the ordering of the statements.
	ConsumedCapacity []types.ConsumedCapacity

	// The response to each PartiQL statement in the batch. The values of the list are
	// ordered according to the ordering of the request statements.
	Responses []types.BatchStatementResponse

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type BatchGetItemAPIClient interface {
	BatchGetItem(context.Context, *BatchGetItemInput, ...func(*Options)) (*BatchGetItemOutput, error)
}

type BatchGetItemInput struct {

	// A map of one or more table names or table ARNs and, for each table, a map that
	// describes one or more items to retrieve from that table. Each table name or ARN
	// 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.
	//
	// This member is required.
	RequestItems map[string]types.KeysAndAttributes

	// Determines the level of detail about either provisioned or on-demand 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
	// contains filtered or unexported fields
}

type BatchGetItemOutput struct {

	// 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 table name or table ARN to a list of items. Each object in Responses
	// consists of a table name or ARN, along with a map of attribute data consisting
	// of the data type and attribute value.
	Responses map[string][]map[string]types.AttributeValue

	// 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
	// contains filtered or unexported fields
}

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

type BatchGetItemPaginatorOptions struct {
	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type BatchWriteItemInput struct {

	// A map of one or more table names or table ARNs 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.
	//
	// This member is required.
	RequestItems map[string][]types.WriteRequest

	// Determines the level of detail about either provisioned or on-demand 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 are returned in the response. If set to NONE (the
	// default), no statistics are returned.
	ReturnItemCollectionMetrics types.ReturnItemCollectionMetrics
	// contains filtered or unexported fields
}

type BatchWriteItemOutput struct {

	// 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

	// 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 BatchWriteItem operation. For more
	// information, see RequestItems in the Request Parameters section. Each
	// UnprocessedItems entry consists of a table name or table ARN 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

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type CreateBackupInput struct {

	// Specified name for the backup.
	//
	// This member is required.
	BackupName *string

	// The name of the table. You can also provide the Amazon Resource Name (ARN) of
	// the table in this parameter.
	//
	// This member is required.
	TableName *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type CreateGlobalTableInput struct {

	// The global table name.
	//
	// This member is required.
	GlobalTableName *string

	// The Regions where the global table needs to be created.
	//
	// This member is required.
	ReplicationGroup []types.Replica
	// contains filtered or unexported fields
}

type CreateGlobalTableOutput struct {

	// Contains the details of the global table.
	GlobalTableDescription *types.GlobalTableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type CreateTableInput struct {

	// An array of attributes that describe the key schema for the table and indexes.
	//
	// This member is required.
	AttributeDefinitions []types.AttributeDefinition

	// 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.
	// For a simple primary key (partition key), you must provide exactly one element
	// with a KeyType of HASH . 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 KeyType of HASH , and the second element must have a KeyType of
	// RANGE . For more information, see Working with Tables (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#WorkingWithTables.primary.key)
	// in the Amazon DynamoDB Developer Guide.
	//
	// This member is required.
	KeySchema []types.KeySchemaElement

	// The name of the table to create. You can also provide the Amazon Resource Name
	// (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string

	// 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

	// Indicates whether deletion protection is to be enabled (true) or disabled
	// (false) on the table.
	DeletionProtectionEnabled *bool

	// 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

	// 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 Service, Account, and
	// Table Quotas (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html)
	// in the Amazon DynamoDB Developer Guide.
	ProvisionedThroughput *types.ProvisionedThroughput

	// An Amazon Web Services resource-based policy document in JSON format that will
	// be attached to the table. When you attach a resource-based policy while creating
	// a table, the policy creation is strongly consistent. The maximum size supported
	// for a resource-based policy document is 20 KB. DynamoDB counts whitespaces when
	// calculating the size of a policy against this limit. You can’t request an
	// increase for this limit. For a full list of all considerations that you should
	// keep in mind while attaching a resource-based policy, see Resource-based policy
	// considerations (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/rbac-considerations.html)
	// .
	ResourcePolicy *string

	// 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

	// The table class of the new table. Valid values are STANDARD and
	// STANDARD_INFREQUENT_ACCESS .
	TableClass types.TableClass

	// 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
	// contains filtered or unexported fields
}

type CreateTableOutput struct {

	// Represents the properties of the table.
	TableDescription *types.TableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteBackupInput struct {

	// The ARN associated with the backup.
	//
	// This member is required.
	BackupArn *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type DeleteItemInput struct {

	// 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 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.
	//
	// This member is required.
	Key map[string]types.AttributeValue

	// The name of the table from which to delete the item. You can also provide the
	// Amazon Resource Name (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string

	// 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

	// 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

	// 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

	// 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 either provisioned or on-demand 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 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 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.
	// 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 ReturnValues parameter is used by
	// several DynamoDB operations; however, DeleteItem does not recognize any values
	// other than NONE or ALL_OLD .
	ReturnValues types.ReturnValue

	// An optional parameter that returns the item attributes for a DeleteItem
	// operation that failed a condition check. 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.
	ReturnValuesOnConditionCheckFailure types.ReturnValuesOnConditionCheckFailure
	// contains filtered or unexported fields
}

type DeleteItemOutput struct {

	// 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 Throughput (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html)
	// in the Amazon DynamoDB Developer Guide.
	ConsumedCapacity *types.ConsumedCapacity

	// 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

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteResourcePolicyInput struct {

	// The Amazon Resource Name (ARN) of the DynamoDB resource from which the policy
	// will be removed. The resources you can specify include tables and streams. If
	// you remove the policy of a table, it will also remove the permissions for the
	// table's indexes defined in that policy document. This is because index
	// permissions are defined in the table's policy.
	//
	// This member is required.
	ResourceArn *string

	// A string value that you can use to conditionally delete your policy. When you
	// provide an expected revision ID, if the revision ID of the existing policy on
	// the resource doesn't match or if there's no policy attached to the resource, the
	// request will fail and return a PolicyNotFoundException .
	ExpectedRevisionId *string
	// contains filtered or unexported fields
}

type DeleteResourcePolicyOutput struct {

	// A unique string that represents the revision ID of the policy. If you are
	// comparing revision IDs, make sure to always use string comparison logic. This
	// value will be empty if you make a request against a resource without a policy.
	RevisionId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DeleteTableInput struct {

	// The name of the table to delete. You can also provide the Amazon Resource Name
	// (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string
	// contains filtered or unexported fields
}

type DeleteTableOutput struct {

	// Represents the properties of a table.
	TableDescription *types.TableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DescribeBackupInput struct {

	// The Amazon Resource Name (ARN) associated with the backup.
	//
	// This member is required.
	BackupArn *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type DescribeContinuousBackupsInput struct {

	// Name of the table for which the customer wants to check the continuous backups
	// and point in time recovery settings. You can also provide the Amazon Resource
	// Name (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type DescribeContributorInsightsInput struct {

	// The name of the table to describe. You can also provide the Amazon Resource
	// Name (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string

	// The name of the global secondary index to describe, if applicable.
	IndexName *string
	// contains filtered or unexported fields
}

type DescribeContributorInsightsOutput struct {

	// List of names of the associated contributor insights rules.
	ContributorInsightsRuleList []string

	// Current status of contributor insights.
	ContributorInsightsStatus types.ContributorInsightsStatus

	// Returns information about the last failure that was 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

	// The name of the global secondary index being described.
	IndexName *string

	// Timestamp of the last time the status was changed.
	LastUpdateDateTime *time.Time

	// The name of the table being described.
	TableName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type DescribeEndpointsOutput struct {

	// List of endpoints.
	//
	// This member is required.
	Endpoints []types.Endpoint

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DescribeExportInput struct {

	// The Amazon Resource Name (ARN) associated with the export.
	//
	// This member is required.
	ExportArn *string
	// contains filtered or unexported fields
}

type DescribeExportOutput struct {

	// Represents the properties of the export.
	ExportDescription *types.ExportDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DescribeGlobalTableInput struct {

	// The name of the global table.
	//
	// This member is required.
	GlobalTableName *string
	// contains filtered or unexported fields
}

type DescribeGlobalTableOutput struct {

	// Contains the details of the global table.
	GlobalTableDescription *types.GlobalTableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DescribeGlobalTableSettingsInput struct {

	// The name of the global table to describe.
	//
	// This member is required.
	GlobalTableName *string
	// contains filtered or unexported fields
}

type DescribeGlobalTableSettingsOutput struct {

	// The name of the global table.
	GlobalTableName *string

	// The Region-specific settings for the global table.
	ReplicaSettings []types.ReplicaSettingsDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DescribeImportInput struct {

	// The Amazon Resource Name (ARN) associated with the table you're importing to.
	//
	// This member is required.
	ImportArn *string
	// contains filtered or unexported fields
}

type DescribeImportOutput struct {

	// Represents the properties of the table created for the import, and parameters
	// of the import. The import parameters include import status, how many items were
	// processed, and how many errors were encountered.
	//
	// This member is required.
	ImportTableDescription *types.ImportTableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DescribeKinesisStreamingDestinationInput struct {

	// The name of the table being described. You can also provide the Amazon Resource
	// Name (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string
	// contains filtered or unexported fields
}

type DescribeKinesisStreamingDestinationOutput struct {

	// The list of replica structures for the table being described.
	KinesisDataStreamDestinations []types.KinesisDataStreamDestination

	// The name of the table being described.
	TableName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type DescribeLimitsOutput struct {

	// The maximum total read capacity units that your account allows you to provision
	// across all of your tables in this Region.
	AccountMaxReadCapacityUnits *int64

	// 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 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 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

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DescribeTableAPIClient interface {
	DescribeTable(context.Context, *DescribeTableInput, ...func(*Options)) (*DescribeTableOutput, error)
}

type DescribeTableInput struct {

	// The name of the table to describe. You can also provide the Amazon Resource
	// Name (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string
	// contains filtered or unexported fields
}

type DescribeTableOutput struct {

	// The properties of the table.
	Table *types.TableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DescribeTableReplicaAutoScalingInput struct {

	// The name of the table. You can also provide the Amazon Resource Name (ARN) of
	// the table in this parameter.
	//
	// This member is required.
	TableName *string
	// contains filtered or unexported fields
}

type DescribeTableReplicaAutoScalingOutput struct {

	// Represents the auto scaling properties of the table.
	TableAutoScalingDescription *types.TableAutoScalingDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DescribeTimeToLiveInput struct {

	// The name of the table to be described. You can also provide the Amazon Resource
	// Name (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string
	// contains filtered or unexported fields
}

type DescribeTimeToLiveOutput struct {

	//
	TimeToLiveDescription *types.TimeToLiveDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type DisableKinesisStreamingDestinationInput struct {

	// The ARN for a Kinesis data stream.
	//
	// This member is required.
	StreamArn *string

	// The name of the DynamoDB table. You can also provide the Amazon Resource Name
	// (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string

	// The source for the Kinesis streaming information that is being enabled.
	EnableKinesisStreamingConfiguration *types.EnableKinesisStreamingConfiguration
	// contains filtered or unexported fields
}

type DisableKinesisStreamingDestinationOutput struct {

	// The current status of the replication.
	DestinationStatus types.DestinationStatus

	// The destination for the Kinesis streaming information that is being enabled.
	EnableKinesisStreamingConfiguration *types.EnableKinesisStreamingConfiguration

	// The ARN for the specific Kinesis data stream.
	StreamArn *string

	// The name of the table being modified.
	TableName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type EnableKinesisStreamingDestinationInput struct {

	// The ARN for a Kinesis data stream.
	//
	// This member is required.
	StreamArn *string

	// The name of the DynamoDB table. You can also provide the Amazon Resource Name
	// (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string

	// The source for the Kinesis streaming information that is being enabled.
	EnableKinesisStreamingConfiguration *types.EnableKinesisStreamingConfiguration
	// contains filtered or unexported fields
}

type EnableKinesisStreamingDestinationOutput struct {

	// The current status of the replication.
	DestinationStatus types.DestinationStatus

	// The destination for the Kinesis streaming information that is being enabled.
	EnableKinesisStreamingConfiguration *types.EnableKinesisStreamingConfiguration

	// The ARN for the specific Kinesis data stream.
	StreamArn *string

	// The name of the table being modified.
	TableName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type EndpointDiscoveryOptions struct {
	// Enables endpoint discovery
	EnableEndpointDiscovery aws.EndpointDiscoveryEnableState
}

type EndpointParameters struct {
	// The AWS region used to dispatch the request.
	//
	// Parameter is
	// required.
	//
	// AWS::Region
	Region *string

	// When true, use the dual-stack endpoint. If the configured endpoint does not
	// support dual-stack, dispatching the request MAY return an error.
	//
	// Defaults to
	// false if no value is provided.
	//
	// AWS::UseDualStack
	UseDualStack *bool

	// When true, send this request to the FIPS-compliant regional endpoint. If the
	// configured endpoint does not have a FIPS compliant endpoint, dispatching the
	// request will return an error.
	//
	// Defaults to false if no value is
	// provided.
	//
	// AWS::UseFIPS
	UseFIPS *bool

	// Override the endpoint used to send this request
	//
	// Parameter is
	// required.
	//
	// SDK::Endpoint
	Endpoint *string
}

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

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

type EndpointResolverOptions = internalendpoints.Options

type EndpointResolverV2 interface {
	// ResolveEndpoint attempts to resolve the endpoint with the provided options,
	// returning the endpoint if found. Otherwise an error is returned.
	ResolveEndpoint(ctx context.Context, params EndpointParameters) (
		smithyendpoints.Endpoint, error,
	)
}

type ExecuteStatementInput struct {

	// The PartiQL statement representing the operation to run.
	//
	// This member is required.
	Statement *string

	// The consistency of a read operation. If set to true , then a strongly consistent
	// read is used; otherwise, an eventually consistent read is used.
	ConsistentRead *bool

	// 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, along with a key in LastEvaluatedKey to apply in a subsequent
	// operation so 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.
	Limit *int32

	// Set this value to get remaining results, if NextToken was returned in the
	// statement response.
	NextToken *string

	// The parameters for the PartiQL statement, if any.
	Parameters []types.AttributeValue

	// Determines the level of detail about either provisioned or on-demand 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

	// An optional parameter that returns the item attributes for an ExecuteStatement
	// operation that failed a condition check. 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.
	ReturnValuesOnConditionCheckFailure types.ReturnValuesOnConditionCheckFailure
	// contains filtered or unexported fields
}

type ExecuteStatementOutput struct {

	// The capacity units consumed by an operation. The data returned includes the
	// total provisioned throughput consumed, along with statistics for the table and
	// any indexes involved in the operation. ConsumedCapacity is only returned if the
	// request asked for it. 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

	// If a read operation was used, this property will contain the result of the read
	// operation; a map of attribute names and their values. For the write operations
	// this value will be empty.
	Items []map[string]types.AttributeValue

	// 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

	// If the response of a read request exceeds the response payload limit DynamoDB
	// will set this value in the response. If set, you can use that this value in the
	// subsequent request to get the remaining results.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ExecuteTransactionInput struct {

	// The list of PartiQL statements representing the transaction to run.
	//
	// This member is required.
	TransactStatements []types.ParameterizedStatement

	// Set this value to get remaining results, if NextToken was returned in the
	// statement response.
	ClientRequestToken *string

	// Determines the level of detail about either provisioned or on-demand throughput
	// consumption that is returned in the response. For more information, see
	// TransactGetItems (https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html)
	// and TransactWriteItems (https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html)
	// .
	ReturnConsumedCapacity types.ReturnConsumedCapacity
	// contains filtered or unexported fields
}

type ExecuteTransactionOutput struct {

	// The capacity units consumed by the entire operation. The values of the list are
	// ordered according to the ordering of the statements.
	ConsumedCapacity []types.ConsumedCapacity

	// The response to a PartiQL transaction.
	Responses []types.ItemResponse

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ExportTableToPointInTimeInput struct {

	// The name of the Amazon S3 bucket to export the snapshot to.
	//
	// This member is required.
	S3Bucket *string

	// The Amazon Resource Name (ARN) associated with the table to export.
	//
	// This member is required.
	TableArn *string

	// Providing a ClientToken makes the call to ExportTableToPointInTimeInput
	// idempotent, meaning that multiple identical calls have the same effect as one
	// single call. A client token is valid for 8 hours after the first request that
	// uses it is completed. After 8 hours, 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 8 hours, 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 8-hour idempotency window, DynamoDB returns an
	// ImportConflictException .
	ClientToken *string

	// The format for the exported data. Valid values for ExportFormat are
	// DYNAMODB_JSON or ION .
	ExportFormat types.ExportFormat

	// Time in the past from which to export table data, counted in seconds from the
	// start of the Unix epoch. The table export will be a snapshot of the table's
	// state at this point in time.
	ExportTime *time.Time

	// Choice of whether to execute as a full export or incremental export. Valid
	// values are FULL_EXPORT or INCREMENTAL_EXPORT. The default value is FULL_EXPORT.
	// If INCREMENTAL_EXPORT is provided, the IncrementalExportSpecification must also
	// be used.
	ExportType types.ExportType

	// Optional object containing the parameters specific to an incremental export.
	IncrementalExportSpecification *types.IncrementalExportSpecification

	// The ID of the Amazon Web Services account that owns the bucket the export will
	// be stored in. S3BucketOwner is a required parameter when exporting to a S3
	// bucket in another account.
	S3BucketOwner *string

	// The Amazon S3 bucket prefix to use as the file name and path of the exported
	// snapshot.
	S3Prefix *string

	// Type of encryption used on the bucket where export data will be stored. Valid
	// values for S3SseAlgorithm are:
	//   - AES256 - server-side encryption with Amazon S3 managed keys
	//   - KMS - server-side encryption with KMS managed keys
	S3SseAlgorithm types.S3SseAlgorithm

	// The ID of the KMS managed key used to encrypt the S3 bucket where export data
	// will be stored (if applicable).
	S3SseKmsKeyId *string
	// contains filtered or unexported fields
}

type ExportTableToPointInTimeOutput struct {

	// Contains a description of the table export.
	ExportDescription *types.ExportDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type GetItemInput struct {

	// 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.
	//
	// This member is required.
	Key map[string]types.AttributeValue

	// The name of the table containing the requested item. You can also provide the
	// Amazon Resource Name (ARN) of the table in this parameter.
	//
	// This member is required.
	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

	// 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

	// 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 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

	// Determines the level of detail about either provisioned or on-demand 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
	// contains filtered or unexported fields
}

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 Provisioned Throughput (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughput.html#ItemSizeCalculations.Reads)
	// 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
	// contains filtered or unexported fields
}

type GetResourcePolicyInput struct {

	// The Amazon Resource Name (ARN) of the DynamoDB resource to which the policy is
	// attached. The resources you can specify include tables and streams.
	//
	// This member is required.
	ResourceArn *string
	// contains filtered or unexported fields
}

type GetResourcePolicyOutput struct {

	// The resource-based policy document attached to the resource, which can be a
	// table or stream, in JSON format.
	Policy *string

	// A unique string that represents the revision ID of the policy. If you are
	// comparing revision IDs, make sure to always use string comparison logic.
	RevisionId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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, optFns ...func(*v4.SignerOptions)) error
}

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

type ImportTableInput struct {

	// The format of the source data. Valid values for ImportFormat are CSV ,
	// DYNAMODB_JSON or ION .
	//
	// This member is required.
	InputFormat types.InputFormat

	// The S3 bucket that provides the source for the import.
	//
	// This member is required.
	S3BucketSource *types.S3BucketSource

	// Parameters for the table to import the data into.
	//
	// This member is required.
	TableCreationParameters *types.TableCreationParameters

	// Providing a ClientToken makes the call to ImportTableInput idempotent, meaning
	// that multiple identical calls have the same effect as one single call. A client
	// token is valid for 8 hours after the first request that uses it is completed.
	// After 8 hours, 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 8 hours, 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 8-hour
	// idempotency window, DynamoDB returns an IdempotentParameterMismatch exception.
	ClientToken *string

	// Type of compression to be used on the input coming from the imported table.
	InputCompressionType types.InputCompressionType

	// Additional properties that specify how the input is formatted,
	InputFormatOptions *types.InputFormatOptions
	// contains filtered or unexported fields
}

type ImportTableOutput struct {

	// Represents the properties of the table created for the import, and parameters
	// of the import. The import parameters include import status, how many items were
	// processed, and how many errors were encountered.
	//
	// This member is required.
	ImportTableDescription *types.ImportTableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ListBackupsInput struct {

	// The backups from the table specified by BackupType are listed. Where BackupType
	// can be:
	//   - USER - On-demand backup created by you. (The default setting if no other
	//   backup types are specified.)
	//   - SYSTEM - On-demand backup automatically created by DynamoDB.
	//   - ALL - All types of on-demand backups (USER and SYSTEM).
	BackupType types.BackupTypeFilter

	// 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

	// Maximum number of backups to return at once.
	Limit *int32

	// Lists the backups from the table specified in TableName . You can also provide
	// the Amazon Resource Name (ARN) of the table in this parameter.
	TableName *string

	// Only backups created after this time are listed. TimeRangeLowerBound is
	// inclusive.
	TimeRangeLowerBound *time.Time

	// Only backups created before this time are listed. TimeRangeUpperBound is
	// exclusive.
	TimeRangeUpperBound *time.Time
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type ListContributorInsightsAPIClient interface {
	ListContributorInsights(context.Context, *ListContributorInsightsInput, ...func(*Options)) (*ListContributorInsightsOutput, error)
}

type ListContributorInsightsInput struct {

	// Maximum number of results to return per page.
	MaxResults int32

	// A token to for the desired page, if there is one.
	NextToken *string

	// The name of the table. You can also provide the Amazon Resource Name (ARN) of
	// the table in this parameter.
	TableName *string
	// contains filtered or unexported fields
}

type ListContributorInsightsOutput struct {

	// A list of ContributorInsightsSummary.
	ContributorInsightsSummaries []types.ContributorInsightsSummary

	// A token to go to the next page if there is one.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ListContributorInsightsPaginatorOptions struct {
	// Maximum number of results to return per page.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListExportsAPIClient interface {
	ListExports(context.Context, *ListExportsInput, ...func(*Options)) (*ListExportsOutput, error)
}

type ListExportsInput struct {

	// Maximum number of results to return per page.
	MaxResults *int32

	// An optional string that, if supplied, must be copied from the output of a
	// previous call to ListExports . When provided in this manner, the API fetches the
	// next page of results.
	NextToken *string

	// The Amazon Resource Name (ARN) associated with the exported table.
	TableArn *string
	// contains filtered or unexported fields
}

type ListExportsOutput struct {

	// A list of ExportSummary objects.
	ExportSummaries []types.ExportSummary

	// If this value is returned, there are additional results to be displayed. To
	// retrieve them, call ListExports again, with NextToken set to this value.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ListExportsPaginatorOptions struct {
	// Maximum number of results to return per page.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type ListImportsAPIClient interface {
	ListImports(context.Context, *ListImportsInput, ...func(*Options)) (*ListImportsOutput, error)
}

type ListImportsInput struct {

	// An optional string that, if supplied, must be copied from the output of a
	// previous call to ListImports . When provided in this manner, the API fetches the
	// next page of results.
	NextToken *string

	// The number of ImportSummary objects returned in a single page.
	PageSize *int32

	// The Amazon Resource Name (ARN) associated with the table that was imported to.
	TableArn *string
	// contains filtered or unexported fields
}

type ListImportsOutput struct {

	// A list of ImportSummary objects.
	ImportSummaryList []types.ImportSummary

	// If this value is returned, there are additional results to be displayed. To
	// retrieve them, call ListImports again, with NextToken set to this value.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ListImportsPaginatorOptions struct {
	// The number of ImportSummary objects returned in a single page.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListTablesAPIClient interface {
	ListTables(context.Context, *ListTablesInput, ...func(*Options)) (*ListTablesOutput, error)
}

type ListTablesInput struct {

	// 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

	// A maximum number of table names to return. If this parameter is not specified,
	// the limit is 100.
	Limit *int32
	// contains filtered or unexported fields
}

type ListTablesOutput struct {

	// 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

	// 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

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ListTablesPaginatorOptions struct {
	// A maximum number of table names to return. If this parameter is not specified,
	// the limit is 100.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListTagsOfResourceInput struct {

	// The Amazon DynamoDB resource with tags to be listed. This value is an Amazon
	// Resource Name (ARN).
	//
	// This member is required.
	ResourceArn *string

	// 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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

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 optional application specific identifier appended to the User-Agent header.
	AppID string

	// This endpoint will be given as input to an EndpointResolverV2. It is used for
	// providing a custom base endpoint that is subject to modifications by the
	// processing EndpointResolverV2.
	BaseEndpoint *string

	// Configures the events that will be sent to the configured logger.
	ClientLogMode aws.ClientLogMode

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

	// The configuration DefaultsMode that the SDK should use when constructing the
	// clients initial default settings.
	DefaultsMode aws.DefaultsMode

	// 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

	// Allows configuring endpoint discovery
	EndpointDiscovery EndpointDiscoveryOptions

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

	// The service endpoint resolver.
	//
	// Deprecated: Deprecated: EndpointResolver and WithEndpointResolver. Providing a
	// value for this field will likely prevent you from using any endpoint-related
	// service features released after the introduction of EndpointResolverV2 and
	// BaseEndpoint. To migrate an EndpointResolver implementation that uses a custom
	// endpoint, set the client option BaseEndpoint instead.
	EndpointResolver EndpointResolver

	// Resolves the endpoint used for a particular service operation. This should be
	// used over the deprecated EndpointResolver.
	EndpointResolverV2 EndpointResolverV2

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

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

	// The logger writer interface to write logging messages to.
	Logger logging.Logger

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

	// RetryMaxAttempts specifies the maximum number attempts an API client will call
	// an operation that fails with a retryable error. A value of 0 is ignored, and
	// will not be used to configure the API client created default retryer, or modify
	// per operation call's retry max attempts. If specified in an operation call's
	// functional options with a value that is different than the constructed client's
	// Options, the Client's Retryer will be wrapped to use the operation's specific
	// RetryMaxAttempts value.
	RetryMaxAttempts int

	// RetryMode specifies the retry mode the API client will be created with, if
	// Retryer option is not also specified. When creating a new API Clients this
	// member will only be used if the Retryer Options member is nil. This value will
	// be ignored if Retryer is not nil. Currently does not support per operation call
	// overrides, may in the future.
	RetryMode aws.RetryMode

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer. The kind of
	// default retry created by the API client can be changed with the RetryMode
	// option.
	Retryer aws.Retryer

	// The RuntimeEnvironment configuration, only populated if the DefaultsMode is set
	// to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You
	// should not populate this structure programmatically, or rely on the values here
	// within your applications.
	RuntimeEnvironment aws.RuntimeEnvironment

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

	// The auth scheme resolver which determines how to authenticate for each
	// operation.
	AuthSchemeResolver AuthSchemeResolver

	// The list of auth schemes supported by the client.
	AuthSchemes []smithyhttp.AuthScheme
	// contains filtered or unexported fields
}

type PutItemInput struct {

	// 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. For more information about primary
	// keys, see Primary Key (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey)
	// in the Amazon DynamoDB Developer Guide. Each element in the Item map is an
	// AttributeValue object.
	//
	// This member is required.
	Item map[string]types.AttributeValue

	// The name of the table to contain the item. You can also provide the Amazon
	// Resource Name (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string

	// 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

	// 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

	// 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 either provisioned or on-demand 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 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 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 values returned are strongly consistent. 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 ReturnValues parameter is used by several DynamoDB operations;
	// however, PutItem does not recognize any values other than NONE or ALL_OLD .
	ReturnValues types.ReturnValue

	// An optional parameter that returns the item attributes for a PutItem operation
	// that failed a condition check. 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.
	ReturnValuesOnConditionCheckFailure types.ReturnValuesOnConditionCheckFailure
	// contains filtered or unexported fields
}

type PutItemOutput struct {

	// 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

	// 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 Provisioned Throughput (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html)
	// in the Amazon DynamoDB Developer Guide.
	ConsumedCapacity *types.ConsumedCapacity

	// 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

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type PutResourcePolicyInput struct {

	// An Amazon Web Services resource-based policy document in JSON format. The
	// maximum size supported for a resource-based policy document is 20 KB. DynamoDB
	// counts whitespaces when calculating the size of a policy against this limit. For
	// a full list of all considerations that you should keep in mind while attaching a
	// resource-based policy, see Resource-based policy considerations (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/rbac-considerations.html)
	// .
	//
	// This member is required.
	Policy *string

	// The Amazon Resource Name (ARN) of the DynamoDB resource to which the policy
	// will be attached. The resources you can specify include tables and streams. You
	// can control index permissions using the base table's policy. To specify the same
	// permission level for your table and its indexes, you can provide both the table
	// and index Amazon Resource Name (ARN)s in the Resource field of a given Statement
	// in your policy document. Alternatively, to specify different permissions for
	// your table, indexes, or both, you can define multiple Statement fields in your
	// policy document.
	//
	// This member is required.
	ResourceArn *string

	// Set this parameter to true to confirm that you want to remove your permissions
	// to change the policy of this resource in the future.
	ConfirmRemoveSelfResourceAccess bool

	// A string value that you can use to conditionally update your policy. You can
	// provide the revision ID of your existing policy to make mutating requests
	// against that policy. When you provide an expected revision ID, if the revision
	// ID of the existing policy on the resource doesn't match or if there's no policy
	// attached to the resource, your request will be rejected with a
	// PolicyNotFoundException . To conditionally put a policy when no policy exists
	// for the resource, specify NO_POLICY for the revision ID.
	ExpectedRevisionId *string
	// contains filtered or unexported fields
}

type PutResourcePolicyOutput struct {

	// A unique string that represents the revision ID of the policy. If you are
	// comparing revision IDs, make sure to always use string comparison logic.
	RevisionId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type QueryAPIClient interface {
	Query(context.Context, *QueryInput, ...func(*Options)) (*QueryOutput, error)
}

type QueryInput struct {

	// The name of the table containing the requested items. You can also provide the
	// Amazon Resource Name (ARN) of the table in this parameter.
	//
	// This member is required.
	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

	// 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

	// 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

	// 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

	// 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

	// 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 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/Query.FilterExpression.html)
	// in the Amazon DynamoDB Developer Guide.
	FilterExpression *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

	// The condition that specifies the key values for items to be retrieved by the
	// Query action. The condition must perform an equality test on a single partition
	// key value. The condition can optionally perform one of several comparison tests
	// on a single sort key value. This allows Query 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. The partition key equality
	// test is required, and must be specified in the following format:
	// partitionKeyName = :partitionkeyval If you also want to provide a condition for
	// the sort key, it must be combined using AND with the condition for the sort
	// key. Following is an example, using the = comparison operator for the sort key:
	// partitionKeyName
	//     =
	//
	//     :partitionkeyval
	//
	//     AND
	//
	//     sortKeyName
	//
	//     =
	// :sortkeyval Valid comparisons for the sort key condition are as follows:
	//   - sortKeyName = :sortkeyval - true if the sort key value is equal to
	//   :sortkeyval .
	//   - sortKeyName < :sortkeyval - true if the sort key value is less than
	//   :sortkeyval .
	//   - sortKeyName <= :sortkeyval - true if the sort key value is less than or
	//   equal to :sortkeyval .
	//   - sortKeyName > :sortkeyval - true if the sort key value is greater than
	//   :sortkeyval .
	//   - sortKeyName >= :sortkeyval - true if the sort key value is greater than or
	//   equal to :sortkeyval .
	//   - sortKeyName BETWEEN :sortkeyval1 AND :sortkeyval2 - true if the sort key
	//   value is greater than or equal to :sortkeyval1 , and less than or equal to
	//   :sortkeyval2 .
	//   - begins_with ( sortKeyName , :sortkeyval ) - 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 begins_with is
	//   case-sensitive.
	// Use the ExpressionAttributeValues parameter to replace tokens such as
	// :partitionval and :sortval with actual values at runtime. You can optionally
	// use the ExpressionAttributeNames 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 KeyConditionExpression parameter causes an error because
	// Size is a reserved word:
	//   - Size = :myval
	// To work around this, define a placeholder (such a #S ) to represent the
	// attribute name Size. KeyConditionExpression then is as follows:
	//   - #S = :myval
	// For a list of reserved words, see Reserved Words (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html)
	// in the Amazon DynamoDB Developer Guide. For more information on
	// ExpressionAttributeNames and ExpressionAttributeValues , see Using Placeholders
	// for Attribute Names and Values (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ExpressionPlaceholders.html)
	// in the Amazon DynamoDB Developer Guide.
	KeyConditionExpression *string

	// 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

	// 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 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

	// 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

	// Determines the level of detail about either provisioned or on-demand 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

	// 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

	// 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. Note that this uses the same quantity of read capacity units as
	//   getting the items, and is subject to the same item size calculations.
	//   - SPECIFIC_ATTRIBUTES - Returns only the attributes listed in
	//   ProjectionExpression . This return value is equivalent to specifying
	//   ProjectionExpression 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 ProjectionExpression 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 ProjectionExpression
	// together in a single request, unless the value for Select is SPECIFIC_ATTRIBUTES
	// . (This usage is equivalent to specifying ProjectionExpression 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
	// contains filtered or unexported fields
}

type QueryOutput struct {

	// 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 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 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 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

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type QueryPaginatorOptions struct {
	// 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
}

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  EndpointResolverOptions
}

type RestoreTableFromBackupInput struct {

	// The Amazon Resource Name (ARN) associated with the backup.
	//
	// This member is required.
	BackupArn *string

	// The name of the new table to which the backup must be restored.
	//
	// This member is required.
	TargetTableName *string

	// The billing mode of the restored table.
	BillingModeOverride types.BillingMode

	// 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

	// 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

	// Provisioned throughput settings for the restored table.
	ProvisionedThroughputOverride *types.ProvisionedThroughput

	// The new server-side encryption settings for the restored table.
	SSESpecificationOverride *types.SSESpecification
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type RestoreTableToPointInTimeInput struct {

	// The name of the new table to which it must be restored to.
	//
	// This member is required.
	TargetTableName *string

	// The billing mode of the restored table.
	BillingModeOverride types.BillingMode

	// 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

	// 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

	// Provisioned throughput settings for the restored table.
	ProvisionedThroughputOverride *types.ProvisionedThroughput

	// Time in the past to restore the table to.
	RestoreDateTime *time.Time

	// The new server-side encryption settings for the restored table.
	SSESpecificationOverride *types.SSESpecification

	// The DynamoDB table that will be restored. This value is an Amazon Resource Name
	// (ARN).
	SourceTableArn *string

	// Name of the source table that is being restored.
	SourceTableName *string

	// Restore the table to the latest possible time. LatestRestorableDateTime is
	// typically 5 minutes before the current time.
	UseLatestRestorableTime *bool
	// contains filtered or unexported fields
}

type RestoreTableToPointInTimeOutput struct {

	// Represents the properties of a table.
	TableDescription *types.TableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type ScanAPIClient interface {
	Scan(context.Context, *ScanInput, ...func(*Options)) (*ScanOutput, error)
}

type ScanInput struct {

	// The name of the table containing the requested items or if you provide IndexName
	// , the name of the table to which that index belongs. You can also provide the
	// Amazon Resource Name (ARN) of the table in this parameter.
	//
	// This member is required.
	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

	// 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

	// 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

	// 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

	// 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

	// 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 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/Scan.html#Scan.FilterExpression)
	// in the Amazon DynamoDB Developer Guide.
	FilterExpression *string

	// 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

	// 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

	// 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

	// Determines the level of detail about either provisioned or on-demand 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 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

	// 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

	// 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. Note that this uses the same quantity of read capacity units as
	//   getting the items, and is subject to the same item size calculations.
	//   - SPECIFIC_ATTRIBUTES - Returns only the attributes listed in
	//   ProjectionExpression . This return value is equivalent to specifying
	//   ProjectionExpression 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 ProjectionExpression 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 ProjectionExpression
	// together in a single request, unless the value for Select is SPECIFIC_ATTRIBUTES
	// . (This usage is equivalent to specifying ProjectionExpression 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, 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
	// contains filtered or unexported fields
}

type ScanOutput struct {

	// 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/ProvisionedThroughput.html#ItemSizeCalculations.Reads)
	// in the Amazon DynamoDB Developer Guide.
	ConsumedCapacity *types.ConsumedCapacity

	// 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

	// 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 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 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

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

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

type ScanPaginatorOptions struct {
	// 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 TableExistsWaiter struct {
	// contains filtered or unexported fields
}

type TableExistsWaiterOptions 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.
	//
	// Passing options here is functionally equivalent to passing values to this
	// config's ClientOptions field that extend the inner client's APIOptions directly.
	APIOptions []func(*middleware.Stack) error

	// Functional options to be passed to all operations invoked by this client.
	//
	// Function values that modify the inner APIOptions are applied after the waiter
	// config's own APIOptions modifiers.
	ClientOptions []func(*Options)

	// MinDelay is the minimum amount of time to delay between retries. If unset,
	// TableExistsWaiter will use default minimum delay of 20 seconds. Note that
	// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
	MinDelay time.Duration

	// MaxDelay is the maximum amount of time to delay between retries. If unset or
	// set to zero, TableExistsWaiter will use default max delay of 120 seconds. Note
	// that MaxDelay must resolve to value greater than or equal to the MinDelay.
	MaxDelay time.Duration

	// LogWaitAttempts is used to enable logging for waiter retry attempts
	LogWaitAttempts bool

	// Retryable is function that can be used to override the service defined
	// waiter-behavior based on operation output, or returned error. This function is
	// used by the waiter to decide if a state is retryable or a terminal state. By
	// default service-modeled logic will populate this option. This option can thus be
	// used to define a custom waiter state with fall-back to service-modeled waiter
	// state mutators.The function returns an error in case of a failure state. In case
	// of retry state, this function returns a bool value of true and nil error, while
	// in case of success it returns a bool value of false and nil error.
	Retryable func(context.Context, *DescribeTableInput, *DescribeTableOutput, error) (bool, error)
}

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

type TableNotExistsWaiterOptions 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.
	//
	// Passing options here is functionally equivalent to passing values to this
	// config's ClientOptions field that extend the inner client's APIOptions directly.
	APIOptions []func(*middleware.Stack) error

	// Functional options to be passed to all operations invoked by this client.
	//
	// Function values that modify the inner APIOptions are applied after the waiter
	// config's own APIOptions modifiers.
	ClientOptions []func(*Options)

	// MinDelay is the minimum amount of time to delay between retries. If unset,
	// TableNotExistsWaiter will use default minimum delay of 20 seconds. Note that
	// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
	MinDelay time.Duration

	// MaxDelay is the maximum amount of time to delay between retries. If unset or
	// set to zero, TableNotExistsWaiter will use default max delay of 120 seconds.
	// Note that MaxDelay must resolve to value greater than or equal to the MinDelay.
	MaxDelay time.Duration

	// LogWaitAttempts is used to enable logging for waiter retry attempts
	LogWaitAttempts bool

	// Retryable is function that can be used to override the service defined
	// waiter-behavior based on operation output, or returned error. This function is
	// used by the waiter to decide if a state is retryable or a terminal state. By
	// default service-modeled logic will populate this option. This option can thus be
	// used to define a custom waiter state with fall-back to service-modeled waiter
	// state mutators.The function returns an error in case of a failure state. In case
	// of retry state, this function returns a bool value of true and nil error, while
	// in case of success it returns a bool value of false and nil error.
	Retryable func(context.Context, *DescribeTableInput, *DescribeTableOutput, error) (bool, error)
}

type TagResourceInput struct {

	// Identifies the Amazon DynamoDB resource to which tags should be added. This
	// value is an Amazon Resource Name (ARN).
	//
	// This member is required.
	ResourceArn *string

	// The tags to be assigned to the Amazon DynamoDB resource.
	//
	// This member is required.
	Tags []types.Tag
	// contains filtered or unexported fields
}

type TagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type TransactGetItemsInput struct {

	// An ordered array of up to 100 TransactGetItem objects, each of which contains a
	// Get structure.
	//
	// This member is required.
	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
	// contains filtered or unexported fields
}

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 100 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
	// contains filtered or unexported fields
}

type TransactWriteItemsInput struct {

	// An ordered array of up to 100 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 Amazon Web Services
	// account and Region, and no two of them can operate on the same item.
	//
	// This member is required.
	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 either provisioned or on-demand 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
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type UntagResourceInput struct {

	// The DynamoDB resource that the tags will be removed from. This value is an
	// Amazon Resource Name (ARN).
	//
	// This member is required.
	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.
	//
	// This member is required.
	TagKeys []string
	// contains filtered or unexported fields
}

type UntagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateContinuousBackupsInput struct {

	// Represents the settings used to enable point in time recovery.
	//
	// This member is required.
	PointInTimeRecoverySpecification *types.PointInTimeRecoverySpecification

	// The name of the table. You can also provide the Amazon Resource Name (ARN) of
	// the table in this parameter.
	//
	// This member is required.
	TableName *string
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type UpdateContributorInsightsInput struct {

	// Represents the contributor insights action.
	//
	// This member is required.
	ContributorInsightsAction types.ContributorInsightsAction

	// The name of the table. You can also provide the Amazon Resource Name (ARN) of
	// the table in this parameter.
	//
	// This member is required.
	TableName *string

	// The global secondary index name, if applicable.
	IndexName *string
	// contains filtered or unexported fields
}

type UpdateContributorInsightsOutput struct {

	// The status of contributor insights
	ContributorInsightsStatus types.ContributorInsightsStatus

	// The name of the global secondary index, if applicable.
	IndexName *string

	// The name of the table.
	TableName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateGlobalTableInput struct {

	// The global table name.
	//
	// This member is required.
	GlobalTableName *string

	// A list of Regions that should be added or removed from the global table.
	//
	// This member is required.
	ReplicaUpdates []types.ReplicaUpdate
	// contains filtered or unexported fields
}

type UpdateGlobalTableOutput struct {

	// Contains the details of the global table.
	GlobalTableDescription *types.GlobalTableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateGlobalTableSettingsInput struct {

	// The name of the global table
	//
	// This member is required.
	GlobalTableName *string

	// 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

	// Represents the settings of a global secondary index for a global table that
	// will be modified.
	GlobalTableGlobalSecondaryIndexSettingsUpdate []types.GlobalTableGlobalSecondaryIndexSettingsUpdate

	// Auto scaling settings for managing provisioned write capacity for the global
	// table.
	GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate *types.AutoScalingSettingsUpdate

	// The maximum number of writes consumed per second before DynamoDB returns a
	// ThrottlingException.
	GlobalTableProvisionedWriteCapacityUnits *int64

	// Represents the settings for a global table in a Region that will be modified.
	ReplicaSettingsUpdate []types.ReplicaSettingsUpdate
	// contains filtered or unexported fields
}

type UpdateGlobalTableSettingsOutput struct {

	// The name of the global table.
	GlobalTableName *string

	// The Region-specific settings for the global table.
	ReplicaSettings []types.ReplicaSettingsDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateItemInput struct {

	// 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.
	//
	// This member is required.
	Key map[string]types.AttributeValue

	// The name of the table containing the item to update. You can also provide the
	// Amazon Resource Name (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string

	// 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

	// 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

	// 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

	// 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

	// 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 either provisioned or on-demand 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 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 successfully 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

	// An optional parameter that returns the item attributes for an UpdateItem
	// operation that failed a condition check. 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.
	ReturnValuesOnConditionCheckFailure types.ReturnValuesOnConditionCheckFailure

	// 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 + :val SET 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.
	// You can have many actions in a single expression, such as the following: SET
	// a=:value1, b=:value2 DELETE :value3, :value4, :value5 For more information on
	// update expressions, see Modifying Items and Attributes (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.Modifying.html)
	// in the Amazon DynamoDB Developer Guide.
	UpdateExpression *string
	// contains filtered or unexported fields
}

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 the update was successful and ReturnValues was specified as
	// something other than NONE in the request. Each element represents one attribute.
	Attributes map[string]types.AttributeValue

	// 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/ProvisionedThroughput.html#ItemSizeCalculations.Reads)
	// in the Amazon DynamoDB Developer Guide.
	ConsumedCapacity *types.ConsumedCapacity

	// 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

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateKinesisStreamingDestinationInput struct {

	// The Amazon Resource Name (ARN) for the Kinesis stream input.
	//
	// This member is required.
	StreamArn *string

	// The table name for the Kinesis streaming destination input. You can also
	// provide the ARN of the table in this parameter.
	//
	// This member is required.
	TableName *string

	// The command to update the Kinesis stream configuration.
	UpdateKinesisStreamingConfiguration *types.UpdateKinesisStreamingConfiguration
	// contains filtered or unexported fields
}

type UpdateKinesisStreamingDestinationOutput struct {

	// The status of the attempt to update the Kinesis streaming destination output.
	DestinationStatus types.DestinationStatus

	// The ARN for the Kinesis stream input.
	StreamArn *string

	// The table name for the Kinesis streaming destination output.
	TableName *string

	// The command to update the Kinesis streaming destination configuration.
	UpdateKinesisStreamingConfiguration *types.UpdateKinesisStreamingConfiguration

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateTableInput struct {

	// The name of the table to be updated. You can also provide the Amazon Resource
	// Name (ARN) of the table in this parameter.
	//
	// This member is required.
	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

	// 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

	// Indicates whether deletion protection is to be enabled (true) or disabled
	// (false) on the table.
	DeletionProtectionEnabled *bool

	// 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

	// 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 (Current) (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html)
	// of global tables.
	ReplicaUpdates []types.ReplicationGroupUpdate

	// The new server-side encryption settings for the specified table.
	SSESpecification *types.SSESpecification

	// Represents the DynamoDB Streams configuration for the table. You receive a
	// ValidationException 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

	// The table class of the table to be updated. Valid values are STANDARD and
	// STANDARD_INFREQUENT_ACCESS .
	TableClass types.TableClass
	// contains filtered or unexported fields
}

type UpdateTableOutput struct {

	// Represents the properties of the table.
	TableDescription *types.TableDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}

type UpdateTableReplicaAutoScalingInput struct {

	// The name of the global table to be updated. You can also provide the Amazon
	// Resource Name (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string

	// Represents the auto scaling settings of the global secondary indexes of the
	// replica to be updated.
	GlobalSecondaryIndexUpdates []types.GlobalSecondaryIndexAutoScalingUpdate

	// Represents the auto scaling settings to be modified for a global table or
	// global secondary index.
	ProvisionedWriteCapacityAutoScalingUpdate *types.AutoScalingSettingsUpdate

	// Represents the auto scaling settings of replicas of the table that will be
	// modified.
	ReplicaUpdates []types.ReplicaAutoScalingUpdate
	// contains filtered or unexported fields
}

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
	// contains filtered or unexported fields
}

type UpdateTimeToLiveInput struct {

	// The name of the table to be configured. You can also provide the Amazon
	// Resource Name (ARN) of the table in this parameter.
	//
	// This member is required.
	TableName *string

	// Represents the settings used to enable or disable Time to Live for the
	// specified table.
	//
	// This member is required.
	TimeToLiveSpecification *types.TimeToLiveSpecification
	// contains filtered or unexported fields
}

type UpdateTimeToLiveOutput struct {

	// Represents the output of an UpdateTimeToLive operation.
	TimeToLiveSpecification *types.TimeToLiveSpecification

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
	// contains filtered or unexported fields
}