def delete_item(options = {})
      options = options.merge(table_name: @name)
      resp = @client.delete_item(options)
      resp.data
    end
def delete_item(options = {})
      options = options.merge(table_name: @name)
      resp = @client.delete_item(options)
      resp.data
    end
@example Request syntax with placeholder values

   table.delete_item({
     key: { # required
       "AttributeName" => "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
     },
     expected: {
       "AttributeName" => {
         value: "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
         exists: false,
         comparison_operator: "EQ", # accepts EQ, NE, IN, LE, LT, GE, GT, BETWEEN, NOT_NULL, NULL, CONTAINS, NOT_CONTAINS, BEGINS_WITH
         attribute_value_list: ["value"], # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
       },
     },
     conditional_operator: "AND", # accepts AND, OR
     return_values: "NONE", # accepts NONE, ALL_OLD, UPDATED_OLD, ALL_NEW, UPDATED_NEW
     return_consumed_capacity: "INDEXES", # accepts INDEXES, TOTAL, NONE
     return_item_collection_metrics: "SIZE", # accepts SIZE, NONE
     condition_expression: "ConditionExpression",
     expression_attribute_names: {
       "ExpressionAttributeNameVariable" => "AttributeName",
     },
     expression_attribute_values: {
       "ExpressionAttributeValueVariable" => "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
     },
   })
 @param [Hash] options ({})
 @option options [required, Hash<String,Types::AttributeValue>] :key
   A map of attribute names to `AttributeValue` objects, representing the
   primary key of the item to delete.

   For the primary key, you must provide all of the attributes. For
   example, with a simple primary key, you only need to provide a value
   for the partition key. For a composite primary key, you must provide
   values for both the partition key and the sort key.
 @option options [Hash<String,Types::ExpectedAttributeValue>] :expected
   This is a legacy parameter. Use `ConditionExpression` instead. For
   more information, see [Expected][1] in the *Amazon DynamoDB Developer
   Guide*.



   [1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.Expected.html
 @option options [String] :conditional_operator
   This is a legacy parameter. Use `ConditionExpression` instead. For
   more information, see [ConditionalOperator][1] in the *Amazon DynamoDB
   Developer Guide*.



   [1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html
 @option options [String] :return_values
   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.

   <note markdown="1"> The `ReturnValues` parameter is used by several DynamoDB operations;
   however, `DeleteItem` does not recognize any values other than `NONE`
   or `ALL_OLD`.

    </note>
 @option options [String] :return_consumed_capacity
   Determines the level of detail about provisioned throughput
   consumption that is returned in the response:

   * `INDEXES` - The response includes the aggregate `ConsumedCapacity`
     for the operation, together with `ConsumedCapacity` for each table
     and secondary index that was accessed.

     Note that some operations, such as `GetItem` and `BatchGetItem`, do
     not access any indexes at all. In these cases, specifying `INDEXES`
     will only return `ConsumedCapacity` information for table(s).

   * `TOTAL` - The response includes only the aggregate
     `ConsumedCapacity` for the operation.

   * `NONE` - No `ConsumedCapacity` details are included in the response.
 @option options [String] :return_item_collection_metrics
   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.
 @option options [String] :condition_expression
   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 on condition expressions, see [Specifying
   Conditions][1] in the *Amazon DynamoDB Developer Guide*.



   [1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html
 @option options [Hash<String,String>] :expression_attribute_names
   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][1] 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`

   ^

   <note markdown="1"> Tokens that begin with the **\:** character are *expression attribute
   values*, which are placeholders for the actual value at runtime.

    </note>

   For more information on expression attribute names, see [Accessing
   Item Attributes][2] in the *Amazon DynamoDB Developer Guide*.



   [1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html
   [2]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html
 @option options [Hash<String,Types::AttributeValue>] :expression_attribute_values
   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][1] in the *Amazon DynamoDB Developer Guide*.



   [1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html
 @return [Types::DeleteItemOutput]