# WARNING ABOUT GENERATED CODE
#
# This file is generated. See the contributing guide for more information:
# https://github.com/aws/aws-sdk-ruby/blob/version-3/CONTRIBUTING.md
#
# WARNING ABOUT GENERATED CODE

module Aws
  module DynamoDB
    # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Resource.html
    class Resource
      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Resource.html#initialize-instance_method
      def initialize: (
                        ?client: Client,
                        ?credentials: untyped,
                        ?region: String,
                        ?access_key_id: String,
                        ?active_endpoint_cache: bool,
                        ?adaptive_retry_wait_to_fill: bool,
                        ?client_side_monitoring: bool,
                        ?client_side_monitoring_client_id: String,
                        ?client_side_monitoring_host: String,
                        ?client_side_monitoring_port: Integer,
                        ?client_side_monitoring_publisher: untyped,
                        ?compute_checksums: bool,
                        ?convert_params: bool,
                        ?correct_clock_skew: bool,
                        ?defaults_mode: String,
                        ?disable_host_prefix_injection: bool,
                        ?disable_request_compression: bool,
                        ?endpoint: String,
                        ?endpoint_cache_max_entries: Integer,
                        ?endpoint_cache_max_threads: Integer,
                        ?endpoint_cache_poll_interval: Integer,
                        ?endpoint_discovery: bool,
                        ?ignore_configured_endpoint_urls: bool,
                        ?log_formatter: untyped,
                        ?log_level: Symbol,
                        ?logger: untyped,
                        ?max_attempts: Integer,
                        ?profile: String,
                        ?request_min_compression_size_bytes: Integer,
                        ?retry_backoff: Proc,
                        ?retry_base_delay: Float,
                        ?retry_jitter: (:none | :equal | :full | ^(Integer) -> Integer),
                        ?retry_limit: Integer,
                        ?retry_max_delay: Integer,
                        ?retry_mode: ("legacy" | "standard" | "adaptive"),
                        ?sdk_ua_app_id: String,
                        ?secret_access_key: String,
                        ?session_token: String,
                        ?sigv4a_signing_region_set: Array[String],
                        ?simple_attributes: bool,
                        ?simple_json: bool,
                        ?stub_responses: untyped,
                        ?token_provider: untyped,
                        ?use_dualstack_endpoint: bool,
                        ?use_fips_endpoint: bool,
                        ?validate_params: bool,
                        ?endpoint_provider: untyped,
                        ?http_proxy: String,
                        ?http_open_timeout: (Float | Integer),
                        ?http_read_timeout: (Float | Integer),
                        ?http_idle_timeout: (Float | Integer),
                        ?http_continue_timeout: (Float | Integer),
                        ?ssl_timeout: (Float | Integer | nil),
                        ?http_wire_trace: bool,
                        ?ssl_verify_peer: bool,
                        ?ssl_ca_bundle: String,
                        ?ssl_ca_directory: String,
                        ?ssl_ca_store: String,
                        ?on_chunk_received: Proc,
                        ?on_chunk_sent: Proc,
                        ?raise_response_errors: bool
                      ) -> void
                    | (?Hash[Symbol, untyped]) -> void

      def client: () -> Client


      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Resource.html#batch_get_item-instance_method
      def batch_get_item: (
                            request_items: Hash[::String, {
                                keys: Array[
                                  Hash[::String, untyped],
                                ],
                                attributes_to_get: Array[::String]?,
                                consistent_read: bool?,
                                projection_expression: ::String?,
                                expression_attribute_names: Hash[::String, ::String]?
                              }],
                            ?return_consumed_capacity: ("INDEXES" | "TOTAL" | "NONE")
                          ) -> Types::BatchGetItemOutput
                        | (?Hash[Symbol, untyped]) -> Types::BatchGetItemOutput

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Resource.html#batch_write_item-instance_method
      def batch_write_item: (
                              request_items: Hash[::String, Array[
                                  {
                                    put_request: {
                                      item: Hash[::String, untyped]
                                    }?,
                                    delete_request: {
                                      key: Hash[::String, untyped]
                                    }?
                                  },
                                ]],
                              ?return_consumed_capacity: ("INDEXES" | "TOTAL" | "NONE"),
                              ?return_item_collection_metrics: ("SIZE" | "NONE")
                            ) -> Types::BatchWriteItemOutput
                          | (?Hash[Symbol, untyped]) -> Types::BatchWriteItemOutput

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Resource.html#create_table-instance_method
      def create_table: (
                          attribute_definitions: Array[
                            {
                              attribute_name: ::String,
                              attribute_type: ("S" | "N" | "B")
                            },
                          ],
                          table_name: ::String,
                          key_schema: Array[
                            {
                              attribute_name: ::String,
                              key_type: ("HASH" | "RANGE")
                            },
                          ],
                          ?local_secondary_indexes: Array[
                            {
                              index_name: ::String,
                              key_schema: Array[
                                {
                                  attribute_name: ::String,
                                  key_type: ("HASH" | "RANGE")
                                },
                              ],
                              projection: {
                                projection_type: ("ALL" | "KEYS_ONLY" | "INCLUDE")?,
                                non_key_attributes: Array[::String]?
                              }
                            },
                          ],
                          ?global_secondary_indexes: Array[
                            {
                              index_name: ::String,
                              key_schema: Array[
                                {
                                  attribute_name: ::String,
                                  key_type: ("HASH" | "RANGE")
                                },
                              ],
                              projection: {
                                projection_type: ("ALL" | "KEYS_ONLY" | "INCLUDE")?,
                                non_key_attributes: Array[::String]?
                              },
                              provisioned_throughput: {
                                read_capacity_units: ::Integer,
                                write_capacity_units: ::Integer
                              }?,
                              on_demand_throughput: {
                                max_read_request_units: ::Integer?,
                                max_write_request_units: ::Integer?
                              }?
                            },
                          ],
                          ?billing_mode: ("PROVISIONED" | "PAY_PER_REQUEST"),
                          ?provisioned_throughput: {
                            read_capacity_units: ::Integer,
                            write_capacity_units: ::Integer
                          },
                          ?stream_specification: {
                            stream_enabled: bool,
                            stream_view_type: ("NEW_IMAGE" | "OLD_IMAGE" | "NEW_AND_OLD_IMAGES" | "KEYS_ONLY")?
                          },
                          ?sse_specification: {
                            enabled: bool?,
                            sse_type: ("AES256" | "KMS")?,
                            kms_master_key_id: ::String?
                          },
                          ?tags: Array[
                            {
                              key: ::String,
                              value: ::String
                            },
                          ],
                          ?table_class: ("STANDARD" | "STANDARD_INFREQUENT_ACCESS"),
                          ?deletion_protection_enabled: bool,
                          ?resource_policy: ::String,
                          ?on_demand_throughput: {
                            max_read_request_units: ::Integer?,
                            max_write_request_units: ::Integer?
                          }
                        ) -> Table
                      | (?Hash[Symbol, untyped]) -> Table


      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Resource.html#table-instance_method
      def table: (String name) -> Table

      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Resource.html#tables-instance_method
      def tables: (
                  ) -> Table::Collection
                | (?Hash[Symbol, untyped]) -> Table::Collection
    end
  end
end