def create_table(options = {})
      resp = @client.create_table(options)
      Table.new(
        name: resp.data.table_description.table_name,
        data: resp.data.table_description,
        client: @client
      )
    end
def create_table(options = {})
      resp = @client.create_table(options)
      Table.new(
        name: resp.data.table_description.table_name,
        data: resp.data.table_description,
        client: @client
      )
    end
@example Request syntax with placeholder values

   table = dynamo_db.create_table({
     attribute_definitions: [ # required
       {
         attribute_name: "KeySchemaAttributeName", # required
         attribute_type: "S", # required, accepts S, N, B
       },
     ],
     table_name: "TableName", # required
     key_schema: [ # required
       {
         attribute_name: "KeySchemaAttributeName", # required
         key_type: "HASH", # required, accepts HASH, RANGE
       },
     ],
     local_secondary_indexes: [
       {
         index_name: "IndexName", # required
         key_schema: [ # required
           {
             attribute_name: "KeySchemaAttributeName", # required
             key_type: "HASH", # required, accepts HASH, RANGE
           },
         ],
         projection: { # required
           projection_type: "ALL", # accepts ALL, KEYS_ONLY, INCLUDE
           non_key_attributes: ["NonKeyAttributeName"],
         },
       },
     ],
     global_secondary_indexes: [
       {
         index_name: "IndexName", # required
         key_schema: [ # required
           {
             attribute_name: "KeySchemaAttributeName", # required
             key_type: "HASH", # required, accepts HASH, RANGE
           },
         ],
         projection: { # required
           projection_type: "ALL", # accepts ALL, KEYS_ONLY, INCLUDE
           non_key_attributes: ["NonKeyAttributeName"],
         },
         provisioned_throughput: {
           read_capacity_units: 1, # required
           write_capacity_units: 1, # required
         },
       },
     ],
     billing_mode: "PROVISIONED", # accepts PROVISIONED, PAY_PER_REQUEST
     provisioned_throughput: {
       read_capacity_units: 1, # required
       write_capacity_units: 1, # required
     },
     stream_specification: {
       stream_enabled: false,
       stream_view_type: "NEW_IMAGE", # accepts NEW_IMAGE, OLD_IMAGE, NEW_AND_OLD_IMAGES, KEYS_ONLY
     },
     sse_specification: {
       enabled: false,
       sse_type: "AES256", # accepts AES256, KMS
       kms_master_key_id: "KMSMasterKeyId",
     },
     tags: [
       {
         key: "TagKeyString", # required
         value: "TagValueString", # required
       },
     ],
   })
 @param [Hash] options ({})
 @option options [required, Array<Types::AttributeDefinition>] :attribute_definitions
   An array of attributes that describe the key schema for the table and
   indexes.
 @option options [required, String] :table_name
   The name of the table to create.
 @option options [required, Array<Types::KeySchemaElement>] :key_schema
   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][1] 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

   <note markdown="1"> The partition key of an item is also known as its *hash attribute*.
   The term "hash attribute" derives from 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.

    </note>

   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 [Specifying the Primary Key][2] in the
   *Amazon DynamoDB Developer Guide*.



   [1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataModel.html
   [2]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#WorkingWithTables.primary.key
 @option options [Array<Types::LocalSecondaryIndex>] :local_secondary_indexes
   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 are 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.
 @option options [Array<Types::GlobalSecondaryIndex>] :global_secondary_indexes
   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 are 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.
 @option options [String] :billing_mode
   Controls how you are charged for read and write throughput and how you
   manage capacity. This setting can be changed later.

   * `PROVISIONED` - Sets the billing mode to `PROVISIONED`. We recommend
     using `PROVISIONED` for predictable workloads.

   * `PAY_PER_REQUEST` - Sets the billing mode to `PAY_PER_REQUEST`. We
     recommend using `PAY_PER_REQUEST` for unpredictable workloads.
 @option options [Types::ProvisionedThroughput] :provisioned_throughput
   Represents the provisioned throughput settings for a specified table
   or index. The settings can be modified using the `UpdateTable`
   operation.

   If you set BillingMode as `PROVISIONED`, you must specify this
   property. If you set BillingMode as `PAY_PER_REQUEST`, you cannot
   specify this property.

   For current minimum and maximum provisioned throughput values, see
   [Limits][1] in the *Amazon DynamoDB Developer Guide*.



   [1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html
 @option options [Types::StreamSpecification] :stream_specification
   The settings for DynamoDB Streams on the table. These settings consist
   of:

   * `StreamEnabled` - Indicates whether 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.
 @option options [Types::SSESpecification] :sse_specification
   Represents the settings used to enable server-side encryption.
 @option options [Array<Types::Tag>] :tags
   A list of key-value pairs to label the table. For more information,
   see [Tagging for DynamoDB][1].



   [1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html
 @return [Table]