aws-sdk-kinesis 1.90.0 → 1.91.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6736085f516ca2510d94734bac5c542f0df5de503df98f8fe48484d9e3d9ebd
-  data.tar.gz: d7ca22b1bd87600d8194c9f3f356ab567995abe145494773a5d4c1d7e45b3c1f
+  metadata.gz: d1e34426c44a4ce854921e54df13e6c6385ba4ef35fe40b60dd6f694ecac12b6
+  data.tar.gz: 30648627d2cb5b8b263abb8e112e10ad430f0dbf9dbed11ecd6a46ea6740c063
 SHA512:
-  metadata.gz: b0d5d077174ecee435925a7f8a79cb0ca0636442302af64fdb122b9ff7005e56bed32cc5b51555373aa62901c547a5fa0942b1ab67ec8d400c4ab0e5a523a83d
-  data.tar.gz: 6e31b996883744ea63af66267f26cc7ad879ac1dca7d59625bd73b4bd9c534e7993b39f94e44d9e8aea8042fb17fc6fd99c05c5f90b53f4252753f599f06e920
+  metadata.gz: 706993a2fcad531a516fd329badec84a0bac0afe713945bf512127f48493f71f683998957322b2709ebbdf0c3cb7f84edb60a883576973d0fc7cc680b9148dee
+  data.tar.gz: 1748fe2127434e34100acfa1eab8f00e826277bc915ac473ac1e2cbc14de7562a32c10b7675957dcba56e99229847b7dfe5b6cfe353d39c7ddf4a4f852827e0e

data/CHANGELOG.md

@@ -1,6 +1,11 @@
 Unreleased Changes
 ------------------
 
+1.91.0 (2025-11-03)
+------------------
+
+* Feature - Adds support for MinimumThroughputBillingCommitment with new UpdateAccountSettings API. Adds support to configure warm throughput for on-demand streams in new UpdateStreamWarmThroughput API and existing CreateStream API and UpdateStreamMode API.
+
 1.90.0 (2025-10-31)
 ------------------
 

data/VERSION

@@ -1 +1 @@
-1.90.0
+1.91.0

data/lib/aws-sdk-kinesis/async_client.rb

@@ -745,7 +745,7 @@ module Aws::Kinesis
         tracer: tracer
       )
       context[:gem_name] = 'aws-sdk-kinesis'
-      context[:gem_version] = '1.90.0'
+      context[:gem_version] = '1.91.0'
       Seahorse::Client::Request.new(handlers, context)
     end
 

data/lib/aws-sdk-kinesis/client.rb

@@ -553,13 +553,22 @@ module Aws::Kinesis
     # planning and automatically scale to handle gigabytes of write and read
     # throughput per minute. With the on-demand mode, Kinesis Data Streams
     # automatically manages the shards in order to provide the necessary
-    # throughput. For the data streams with a provisioned mode, you must
-    # specify the number of shards for the data stream. Each shard can
-    # support reads up to five transactions per second, up to a maximum data
-    # read total of 2 MiB per second. Each shard can support writes up to
-    # 1,000 records per second, up to a maximum data write total of 1 MiB
-    # per second. If the amount of data input increases or decreases, you
-    # can add or remove shards.
+    # throughput.
+    #
+    # If you'd still like to proactively scale your on-demand data stream’s
+    # capacity, you can unlock the warm throughput feature for on-demand
+    # data streams by enabling `MinimumThroughputBillingCommitment` for your
+    # account. Once your account has `MinimumThroughputBillingCommitment`
+    # enabled, you can specify the warm throughput in MiB per second that
+    # your stream can support in writes.
+    #
+    # For the data streams with a provisioned mode, you must specify the
+    # number of shards for the data stream. Each shard can support reads up
+    # to five transactions per second, up to a maximum data read total of 2
+    # MiB per second. Each shard can support writes up to 1,000 records per
+    # second, up to a maximum data write total of 1 MiB per second. If the
+    # amount of data input increases or decreases, you can add or remove
+    # shards.
     #
     # The stream name identifies the stream. The name is scoped to the
     # Amazon Web Services account used by the application. It is also scoped
@@ -581,10 +590,10 @@ module Aws::Kinesis
     #
     # * Create more shards than are authorized for your account.
     #
-    # For the default shard limit for an Amazon Web Services account, see
-    # [Amazon Kinesis Data Streams Limits][1] in the *Amazon Kinesis Data
-    # Streams Developer Guide*. To increase this limit, [contact Amazon Web
-    # Services Support][2].
+    # For the default shard or on-demand throughput limits for an Amazon Web
+    # Services account, see [Amazon Kinesis Data Streams Limits][1] in the
+    # *Amazon Kinesis Data Streams Developer Guide*. To increase this limit,
+    # [contact Amazon Web Services Support][2].
     #
     # You can use DescribeStreamSummary to check the stream status, which is
     # returned in `StreamStatus`.
@@ -627,6 +636,11 @@ module Aws::Kinesis
     #   A set of up to 50 key-value pairs to use to create the tags. A tag
     #   consists of a required key and an optional value.
     #
+    # @option params [Integer] :warm_throughput_mi_bps
+    #   The target warm throughput in MB/s that the stream should be scaled to
+    #   handle. This represents the throughput capacity that will be
+    #   immediately available for write operations.
+    #
     # @option params [Integer] :max_record_size_in_ki_b
     #   The maximum record size of a single record in kibibyte (KiB) that you
     #   can write to, and read from a stream.
@@ -644,6 +658,7 @@ module Aws::Kinesis
     #     tags: {
     #       "TagKey" => "TagValue",
     #     },
+    #     warm_throughput_mi_bps: 1,
     #     max_record_size_in_ki_b: 1,
     #   })
     #
@@ -834,6 +849,34 @@ module Aws::Kinesis
       req.send_request(options)
     end
 
+    # Describes the account-level settings for Amazon Kinesis Data Streams.
+    # This operation returns information about the minimum throughput
+    # billing commitments and other account-level configurations.
+    #
+    # This API has a call limit of 5 transactions per second (TPS) for each
+    # Amazon Web Services account. TPS over 5 will initiate the
+    # `LimitExceededException`.
+    #
+    # @return [Types::DescribeAccountSettingsOutput] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
+    #
+    #   * {Types::DescribeAccountSettingsOutput#minimum_throughput_billing_commitment #minimum_throughput_billing_commitment} => Types::MinimumThroughputBillingCommitmentOutput
+    #
+    # @example Response structure
+    #
+    #   resp.minimum_throughput_billing_commitment.status #=> String, one of "ENABLED", "DISABLED", "ENABLED_UNTIL_EARLIEST_ALLOWED_END"
+    #   resp.minimum_throughput_billing_commitment.started_at #=> Time
+    #   resp.minimum_throughput_billing_commitment.ended_at #=> Time
+    #   resp.minimum_throughput_billing_commitment.earliest_allowed_end_at #=> Time
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DescribeAccountSettings AWS API Documentation
+    #
+    # @overload describe_account_settings(params = {})
+    # @param [Hash] params ({})
+    def describe_account_settings(params = {}, options = {})
+      req = build_request(:describe_account_settings, params)
+      req.send_request(options)
+    end
+
     # Describes the shard limits and usage for the account.
     #
     # If you update your account limits, the old limits might be returned
@@ -1087,6 +1130,8 @@ module Aws::Kinesis
     #   resp.stream_description_summary.key_id #=> String
     #   resp.stream_description_summary.open_shard_count #=> Integer
     #   resp.stream_description_summary.consumer_count #=> Integer
+    #   resp.stream_description_summary.warm_throughput.target_mi_bps #=> Integer
+    #   resp.stream_description_summary.warm_throughput.current_mi_bps #=> Integer
     #   resp.stream_description_summary.max_record_size_in_ki_b #=> Integer
     #
     # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DescribeStreamSummary AWS API Documentation
@@ -2850,6 +2895,54 @@ module Aws::Kinesis
       req.send_request(options)
     end
 
+    # Updates the account-level settings for Amazon Kinesis Data Streams.
+    #
+    # Updating account settings is a synchronous operation. Upon receiving
+    # the request, Kinesis Data Streams will return immediately with your
+    # account’s updated settings.
+    #
+    # **API limits**
+    #
+    # * Certain account configurations have minimum commitment windows.
+    #   Attempting to update your settings prior to the end of the minimum
+    #   commitment window might have certain restrictions.
+    #
+    # * This API has a call limit of 5 transactions per second (TPS) for
+    #   each Amazon Web Services account. TPS over 5 will initiate the
+    #   `LimitExceededException`.
+    #
+    # @option params [required, Types::MinimumThroughputBillingCommitmentInput] :minimum_throughput_billing_commitment
+    #   Specifies the minimum throughput billing commitment configuration for
+    #   your account.
+    #
+    # @return [Types::UpdateAccountSettingsOutput] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
+    #
+    #   * {Types::UpdateAccountSettingsOutput#minimum_throughput_billing_commitment #minimum_throughput_billing_commitment} => Types::MinimumThroughputBillingCommitmentOutput
+    #
+    # @example Request syntax with placeholder values
+    #
+    #   resp = client.update_account_settings({
+    #     minimum_throughput_billing_commitment: { # required
+    #       status: "ENABLED", # required, accepts ENABLED, DISABLED
+    #     },
+    #   })
+    #
+    # @example Response structure
+    #
+    #   resp.minimum_throughput_billing_commitment.status #=> String, one of "ENABLED", "DISABLED", "ENABLED_UNTIL_EARLIEST_ALLOWED_END"
+    #   resp.minimum_throughput_billing_commitment.started_at #=> Time
+    #   resp.minimum_throughput_billing_commitment.ended_at #=> Time
+    #   resp.minimum_throughput_billing_commitment.earliest_allowed_end_at #=> Time
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/UpdateAccountSettings AWS API Documentation
+    #
+    # @overload update_account_settings(params = {})
+    # @param [Hash] params ({})
+    def update_account_settings(params = {}, options = {})
+      req = build_request(:update_account_settings, params)
+      req.send_request(options)
+    end
+
     # This allows you to update the `MaxRecordSize` of a single record that
     # you can write to, and read from a stream. You can ingest and digest
     # single records up to 10240 KiB.
@@ -3001,6 +3094,13 @@ module Aws::Kinesis
     # Data Streams, you can choose between an **on-demand** capacity mode
     # and a **provisioned** capacity mode for your data stream.
     #
+    # If you'd still like to proactively scale your on-demand data stream’s
+    # capacity, you can unlock the warm throughput feature for on-demand
+    # data streams by enabling `MinimumThroughputBillingCommitment` for your
+    # account. Once your account has `MinimumThroughputBillingCommitment`
+    # enabled, you can specify the warm throughput in MiB per second that
+    # your stream can support in writes.
+    #
     # @option params [required, String] :stream_arn
     #   Specifies the ARN of the data stream whose capacity mode you want to
     #   update.
@@ -3011,6 +3111,12 @@ module Aws::Kinesis
     #   **on-demand** capacity mode and a **provisioned** capacity mode for
     #   your data streams.
     #
+    # @option params [Integer] :warm_throughput_mi_bps
+    #   The target warm throughput in MB/s that the stream should be scaled to
+    #   handle. This represents the throughput capacity that will be
+    #   immediately available for write operations. This field is only valid
+    #   when the stream mode is being updated to on-demand.
+    #
     # @return [Struct] Returns an empty {Seahorse::Client::Response response}.
     #
     # @example Request syntax with placeholder values
@@ -3020,6 +3126,7 @@ module Aws::Kinesis
     #     stream_mode_details: { # required
     #       stream_mode: "PROVISIONED", # required, accepts PROVISIONED, ON_DEMAND
     #     },
+    #     warm_throughput_mi_bps: 1,
     #   })
     #
     # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/UpdateStreamMode AWS API Documentation
@@ -3031,6 +3138,91 @@ module Aws::Kinesis
       req.send_request(options)
     end
 
+    # Updates the warm throughput configuration for the specified Amazon
+    # Kinesis Data Streams on-demand data stream. This operation allows you
+    # to proactively scale your on-demand data stream to a specified
+    # throughput level, enabling better performance for sudden traffic
+    # spikes.
+    #
+    # <note markdown="1"> When invoking this API, you must use either the `StreamARN` or the
+    # `StreamName` parameter, or both. It is recommended that you use the
+    # `StreamARN` input parameter when you invoke this API.
+    #
+    #  </note>
+    #
+    # Updating the warm throughput is an asynchronous operation. Upon
+    # receiving the request, Kinesis Data Streams returns immediately and
+    # sets the status of the stream to `UPDATING`. After the update is
+    # complete, Kinesis Data Streams sets the status of the stream back to
+    # `ACTIVE`. Depending on the size of the stream, the scaling action
+    # could take a few minutes to complete. You can continue to read and
+    # write data to your stream while its status is `UPDATING`.
+    #
+    # This operation is only supported for data streams with the on-demand
+    # capacity mode in accounts that have
+    # `MinimumThroughputBillingCommitment` enabled. Provisioned capacity
+    # mode streams do not support warm throughput configuration.
+    #
+    # This operation has the following default limits. By default, you
+    # cannot do the following:
+    #
+    # * Scale to more than 10 GiBps for an on-demand stream.
+    #
+    # * This API has a call limit of 5 transactions per second (TPS) for
+    #   each Amazon Web Services account. TPS over 5 will initiate the
+    #   `LimitExceededException`.
+    #
+    # For the default limits for an Amazon Web Services account, see
+    # [Streams Limits][1] in the *Amazon Kinesis Data Streams Developer
+    # Guide*. To request an increase in the call rate limit, the shard limit
+    # for this API, or your overall shard limit, use the [limits form][2].
+    #
+    #
+    #
+    # [1]: https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html
+    # [2]: https://console.aws.amazon.com/support/v1#/case/create?issueType=service-limit-increase&amp;limitType=service-code-kinesis
+    #
+    # @option params [String] :stream_arn
+    #   The ARN of the stream to be updated.
+    #
+    # @option params [String] :stream_name
+    #   The name of the stream to be updated.
+    #
+    # @option params [required, Integer] :warm_throughput_mi_bps
+    #   The target warm throughput in MB/s that the stream should be scaled to
+    #   handle. This represents the throughput capacity that will be
+    #   immediately available for write operations.
+    #
+    # @return [Types::UpdateStreamWarmThroughputOutput] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
+    #
+    #   * {Types::UpdateStreamWarmThroughputOutput#stream_arn #stream_arn} => String
+    #   * {Types::UpdateStreamWarmThroughputOutput#stream_name #stream_name} => String
+    #   * {Types::UpdateStreamWarmThroughputOutput#warm_throughput #warm_throughput} => Types::WarmThroughputObject
+    #
+    # @example Request syntax with placeholder values
+    #
+    #   resp = client.update_stream_warm_throughput({
+    #     stream_arn: "StreamARN",
+    #     stream_name: "StreamName",
+    #     warm_throughput_mi_bps: 1, # required
+    #   })
+    #
+    # @example Response structure
+    #
+    #   resp.stream_arn #=> String
+    #   resp.stream_name #=> String
+    #   resp.warm_throughput.target_mi_bps #=> Integer
+    #   resp.warm_throughput.current_mi_bps #=> Integer
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/UpdateStreamWarmThroughput AWS API Documentation
+    #
+    # @overload update_stream_warm_throughput(params = {})
+    # @param [Hash] params ({})
+    def update_stream_warm_throughput(params = {}, options = {})
+      req = build_request(:update_stream_warm_throughput, params)
+      req.send_request(options)
+    end
+
     # @!endgroup
 
     # @param params ({})
@@ -3049,7 +3241,7 @@ module Aws::Kinesis
         tracer: tracer
       )
       context[:gem_name] = 'aws-sdk-kinesis'
-      context[:gem_version] = '1.90.0'
+      context[:gem_version] = '1.91.0'
       Seahorse::Client::Request.new(handlers, context)
     end
 

data/lib/aws-sdk-kinesis/client_api.rb

@@ -32,6 +32,8 @@ module Aws::Kinesis
     DeleteResourcePolicyInput = Shapes::StructureShape.new(name: 'DeleteResourcePolicyInput')
     DeleteStreamInput = Shapes::StructureShape.new(name: 'DeleteStreamInput')
     DeregisterStreamConsumerInput = Shapes::StructureShape.new(name: 'DeregisterStreamConsumerInput')
+    DescribeAccountSettingsInput = Shapes::StructureShape.new(name: 'DescribeAccountSettingsInput')
+    DescribeAccountSettingsOutput = Shapes::StructureShape.new(name: 'DescribeAccountSettingsOutput')
     DescribeLimitsInput = Shapes::StructureShape.new(name: 'DescribeLimitsInput')
     DescribeLimitsOutput = Shapes::StructureShape.new(name: 'DescribeLimitsOutput')
     DescribeStreamConsumerInput = Shapes::StructureShape.new(name: 'DescribeStreamConsumerInput')
@@ -90,6 +92,11 @@ module Aws::Kinesis
     MetricsName = Shapes::StringShape.new(name: 'MetricsName')
     MetricsNameList = Shapes::ListShape.new(name: 'MetricsNameList')
     MillisBehindLatest = Shapes::IntegerShape.new(name: 'MillisBehindLatest')
+    MinimumThroughputBillingCommitmentInput = Shapes::StructureShape.new(name: 'MinimumThroughputBillingCommitmentInput')
+    MinimumThroughputBillingCommitmentInputStatus = Shapes::StringShape.new(name: 'MinimumThroughputBillingCommitmentInputStatus')
+    MinimumThroughputBillingCommitmentOutput = Shapes::StructureShape.new(name: 'MinimumThroughputBillingCommitmentOutput')
+    MinimumThroughputBillingCommitmentOutputStatus = Shapes::StringShape.new(name: 'MinimumThroughputBillingCommitmentOutputStatus')
+    NaturalIntegerObject = Shapes::IntegerShape.new(name: 'NaturalIntegerObject')
     NextToken = Shapes::StringShape.new(name: 'NextToken')
     OnDemandStreamCountLimitObject = Shapes::IntegerShape.new(name: 'OnDemandStreamCountLimitObject')
     OnDemandStreamCountObject = Shapes::IntegerShape.new(name: 'OnDemandStreamCountObject')
@@ -154,11 +161,16 @@ module Aws::Kinesis
     TagValue = Shapes::StringShape.new(name: 'TagValue')
     Timestamp = Shapes::TimestampShape.new(name: 'Timestamp')
     UntagResourceInput = Shapes::StructureShape.new(name: 'UntagResourceInput')
+    UpdateAccountSettingsInput = Shapes::StructureShape.new(name: 'UpdateAccountSettingsInput')
+    UpdateAccountSettingsOutput = Shapes::StructureShape.new(name: 'UpdateAccountSettingsOutput')
     UpdateMaxRecordSizeInput = Shapes::StructureShape.new(name: 'UpdateMaxRecordSizeInput')
     UpdateShardCountInput = Shapes::StructureShape.new(name: 'UpdateShardCountInput')
     UpdateShardCountOutput = Shapes::StructureShape.new(name: 'UpdateShardCountOutput')
     UpdateStreamModeInput = Shapes::StructureShape.new(name: 'UpdateStreamModeInput')
+    UpdateStreamWarmThroughputInput = Shapes::StructureShape.new(name: 'UpdateStreamWarmThroughputInput')
+    UpdateStreamWarmThroughputOutput = Shapes::StructureShape.new(name: 'UpdateStreamWarmThroughputOutput')
     ValidationException = Shapes::StructureShape.new(name: 'ValidationException')
+    WarmThroughputObject = Shapes::StructureShape.new(name: 'WarmThroughputObject')
 
     AccessDeniedException.add_member(:message, Shapes::ShapeRef.new(shape: ErrorMessage, location_name: "message"))
     AccessDeniedException.struct_class = Types::AccessDeniedException
@@ -194,6 +206,7 @@ module Aws::Kinesis
     CreateStreamInput.add_member(:shard_count, Shapes::ShapeRef.new(shape: PositiveIntegerObject, location_name: "ShardCount"))
     CreateStreamInput.add_member(:stream_mode_details, Shapes::ShapeRef.new(shape: StreamModeDetails, location_name: "StreamModeDetails"))
     CreateStreamInput.add_member(:tags, Shapes::ShapeRef.new(shape: TagMap, location_name: "Tags"))
+    CreateStreamInput.add_member(:warm_throughput_mi_bps, Shapes::ShapeRef.new(shape: NaturalIntegerObject, location_name: "WarmThroughputMiBps"))
     CreateStreamInput.add_member(:max_record_size_in_ki_b, Shapes::ShapeRef.new(shape: MaxRecordSizeInKiB, location_name: "MaxRecordSizeInKiB"))
     CreateStreamInput.struct_class = Types::CreateStreamInput
 
@@ -215,6 +228,11 @@ module Aws::Kinesis
     DeregisterStreamConsumerInput.add_member(:consumer_arn, Shapes::ShapeRef.new(shape: ConsumerARN, location_name: "ConsumerARN", metadata: {"contextParam" => {"name" => "ConsumerARN"}}))
     DeregisterStreamConsumerInput.struct_class = Types::DeregisterStreamConsumerInput
 
+    DescribeAccountSettingsInput.struct_class = Types::DescribeAccountSettingsInput
+
+    DescribeAccountSettingsOutput.add_member(:minimum_throughput_billing_commitment, Shapes::ShapeRef.new(shape: MinimumThroughputBillingCommitmentOutput, location_name: "MinimumThroughputBillingCommitment"))
+    DescribeAccountSettingsOutput.struct_class = Types::DescribeAccountSettingsOutput
+
     DescribeLimitsInput.struct_class = Types::DescribeLimitsInput
 
     DescribeLimitsOutput.add_member(:shard_limit, Shapes::ShapeRef.new(shape: ShardCountObject, required: true, location_name: "ShardLimit"))
@@ -396,6 +414,15 @@ module Aws::Kinesis
 
     MetricsNameList.member = Shapes::ShapeRef.new(shape: MetricsName)
 
+    MinimumThroughputBillingCommitmentInput.add_member(:status, Shapes::ShapeRef.new(shape: MinimumThroughputBillingCommitmentInputStatus, required: true, location_name: "Status"))
+    MinimumThroughputBillingCommitmentInput.struct_class = Types::MinimumThroughputBillingCommitmentInput
+
+    MinimumThroughputBillingCommitmentOutput.add_member(:status, Shapes::ShapeRef.new(shape: MinimumThroughputBillingCommitmentOutputStatus, required: true, location_name: "Status"))
+    MinimumThroughputBillingCommitmentOutput.add_member(:started_at, Shapes::ShapeRef.new(shape: Timestamp, location_name: "StartedAt"))
+    MinimumThroughputBillingCommitmentOutput.add_member(:ended_at, Shapes::ShapeRef.new(shape: Timestamp, location_name: "EndedAt"))
+    MinimumThroughputBillingCommitmentOutput.add_member(:earliest_allowed_end_at, Shapes::ShapeRef.new(shape: Timestamp, location_name: "EarliestAllowedEndAt"))
+    MinimumThroughputBillingCommitmentOutput.struct_class = Types::MinimumThroughputBillingCommitmentOutput
+
     ProvisionedThroughputExceededException.add_member(:message, Shapes::ShapeRef.new(shape: ErrorMessage, location_name: "message"))
     ProvisionedThroughputExceededException.struct_class = Types::ProvisionedThroughputExceededException
 
@@ -536,6 +563,7 @@ module Aws::Kinesis
     StreamDescriptionSummary.add_member(:key_id, Shapes::ShapeRef.new(shape: KeyId, location_name: "KeyId"))
     StreamDescriptionSummary.add_member(:open_shard_count, Shapes::ShapeRef.new(shape: ShardCountObject, required: true, location_name: "OpenShardCount"))
     StreamDescriptionSummary.add_member(:consumer_count, Shapes::ShapeRef.new(shape: ConsumerCountObject, location_name: "ConsumerCount"))
+    StreamDescriptionSummary.add_member(:warm_throughput, Shapes::ShapeRef.new(shape: WarmThroughputObject, location_name: "WarmThroughput"))
     StreamDescriptionSummary.add_member(:max_record_size_in_ki_b, Shapes::ShapeRef.new(shape: MaxRecordSizeInKiB, location_name: "MaxRecordSizeInKiB"))
     StreamDescriptionSummary.struct_class = Types::StreamDescriptionSummary
 
@@ -598,6 +626,12 @@ module Aws::Kinesis
     UntagResourceInput.add_member(:resource_arn, Shapes::ShapeRef.new(shape: ResourceARN, required: true, location_name: "ResourceARN", metadata: {"contextParam" => {"name" => "ResourceARN"}}))
     UntagResourceInput.struct_class = Types::UntagResourceInput
 
+    UpdateAccountSettingsInput.add_member(:minimum_throughput_billing_commitment, Shapes::ShapeRef.new(shape: MinimumThroughputBillingCommitmentInput, required: true, location_name: "MinimumThroughputBillingCommitment"))
+    UpdateAccountSettingsInput.struct_class = Types::UpdateAccountSettingsInput
+
+    UpdateAccountSettingsOutput.add_member(:minimum_throughput_billing_commitment, Shapes::ShapeRef.new(shape: MinimumThroughputBillingCommitmentOutput, location_name: "MinimumThroughputBillingCommitment"))
+    UpdateAccountSettingsOutput.struct_class = Types::UpdateAccountSettingsOutput
+
     UpdateMaxRecordSizeInput.add_member(:stream_arn, Shapes::ShapeRef.new(shape: StreamARN, location_name: "StreamARN", metadata: {"contextParam" => {"name" => "StreamARN"}}))
     UpdateMaxRecordSizeInput.add_member(:max_record_size_in_ki_b, Shapes::ShapeRef.new(shape: MaxRecordSizeInKiB, required: true, location_name: "MaxRecordSizeInKiB"))
     UpdateMaxRecordSizeInput.struct_class = Types::UpdateMaxRecordSizeInput
@@ -616,11 +650,26 @@ module Aws::Kinesis
 
     UpdateStreamModeInput.add_member(:stream_arn, Shapes::ShapeRef.new(shape: StreamARN, required: true, location_name: "StreamARN", metadata: {"contextParam" => {"name" => "StreamARN"}}))
     UpdateStreamModeInput.add_member(:stream_mode_details, Shapes::ShapeRef.new(shape: StreamModeDetails, required: true, location_name: "StreamModeDetails"))
+    UpdateStreamModeInput.add_member(:warm_throughput_mi_bps, Shapes::ShapeRef.new(shape: NaturalIntegerObject, location_name: "WarmThroughputMiBps"))
     UpdateStreamModeInput.struct_class = Types::UpdateStreamModeInput
 
+    UpdateStreamWarmThroughputInput.add_member(:stream_arn, Shapes::ShapeRef.new(shape: StreamARN, location_name: "StreamARN", metadata: {"contextParam" => {"name" => "StreamARN"}}))
+    UpdateStreamWarmThroughputInput.add_member(:stream_name, Shapes::ShapeRef.new(shape: StreamName, location_name: "StreamName"))
+    UpdateStreamWarmThroughputInput.add_member(:warm_throughput_mi_bps, Shapes::ShapeRef.new(shape: NaturalIntegerObject, required: true, location_name: "WarmThroughputMiBps"))
+    UpdateStreamWarmThroughputInput.struct_class = Types::UpdateStreamWarmThroughputInput
+
+    UpdateStreamWarmThroughputOutput.add_member(:stream_arn, Shapes::ShapeRef.new(shape: StreamARN, location_name: "StreamARN"))
+    UpdateStreamWarmThroughputOutput.add_member(:stream_name, Shapes::ShapeRef.new(shape: StreamName, location_name: "StreamName"))
+    UpdateStreamWarmThroughputOutput.add_member(:warm_throughput, Shapes::ShapeRef.new(shape: WarmThroughputObject, location_name: "WarmThroughput"))
+    UpdateStreamWarmThroughputOutput.struct_class = Types::UpdateStreamWarmThroughputOutput
+
     ValidationException.add_member(:message, Shapes::ShapeRef.new(shape: ErrorMessage, location_name: "message"))
     ValidationException.struct_class = Types::ValidationException
 
+    WarmThroughputObject.add_member(:target_mi_bps, Shapes::ShapeRef.new(shape: NaturalIntegerObject, location_name: "TargetMiBps"))
+    WarmThroughputObject.add_member(:current_mi_bps, Shapes::ShapeRef.new(shape: NaturalIntegerObject, location_name: "CurrentMiBps"))
+    WarmThroughputObject.struct_class = Types::WarmThroughputObject
+
 
     # @api private
     API = Seahorse::Model::Api.new.tap do |api|
@@ -665,6 +714,7 @@ module Aws::Kinesis
         o.errors << Shapes::ShapeRef.new(shape: ResourceInUseException)
         o.errors << Shapes::ShapeRef.new(shape: LimitExceededException)
         o.errors << Shapes::ShapeRef.new(shape: InvalidArgumentException)
+        o.errors << Shapes::ShapeRef.new(shape: ValidationException)
       end)
 
       api.add_operation(:decrease_stream_retention_period, Seahorse::Model::Operation.new.tap do |o|
@@ -717,6 +767,15 @@ module Aws::Kinesis
         o.errors << Shapes::ShapeRef.new(shape: InvalidArgumentException)
       end)
 
+      api.add_operation(:describe_account_settings, Seahorse::Model::Operation.new.tap do |o|
+        o.name = "DescribeAccountSettings"
+        o.http_method = "POST"
+        o.http_request_uri = "/"
+        o.input = Shapes::ShapeRef.new(shape: DescribeAccountSettingsInput)
+        o.output = Shapes::ShapeRef.new(shape: DescribeAccountSettingsOutput)
+        o.errors << Shapes::ShapeRef.new(shape: LimitExceededException)
+      end)
+
       api.add_operation(:describe_limits, Seahorse::Model::Operation.new.tap do |o|
         o.name = "DescribeLimits"
         o.http_method = "POST"
@@ -1105,6 +1164,17 @@ module Aws::Kinesis
         o.errors << Shapes::ShapeRef.new(shape: AccessDeniedException)
       end)
 
+      api.add_operation(:update_account_settings, Seahorse::Model::Operation.new.tap do |o|
+        o.name = "UpdateAccountSettings"
+        o.http_method = "POST"
+        o.http_request_uri = "/"
+        o.input = Shapes::ShapeRef.new(shape: UpdateAccountSettingsInput)
+        o.output = Shapes::ShapeRef.new(shape: UpdateAccountSettingsOutput)
+        o.errors << Shapes::ShapeRef.new(shape: InvalidArgumentException)
+        o.errors << Shapes::ShapeRef.new(shape: ValidationException)
+        o.errors << Shapes::ShapeRef.new(shape: LimitExceededException)
+      end)
+
       api.add_operation(:update_max_record_size, Seahorse::Model::Operation.new.tap do |o|
         o.name = "UpdateMaxRecordSize"
         o.http_method = "POST"
@@ -1143,6 +1213,21 @@ module Aws::Kinesis
         o.errors << Shapes::ShapeRef.new(shape: LimitExceededException)
         o.errors << Shapes::ShapeRef.new(shape: ResourceInUseException)
         o.errors << Shapes::ShapeRef.new(shape: ResourceNotFoundException)
+        o.errors << Shapes::ShapeRef.new(shape: ValidationException)
+      end)
+
+      api.add_operation(:update_stream_warm_throughput, Seahorse::Model::Operation.new.tap do |o|
+        o.name = "UpdateStreamWarmThroughput"
+        o.http_method = "POST"
+        o.http_request_uri = "/"
+        o.input = Shapes::ShapeRef.new(shape: UpdateStreamWarmThroughputInput)
+        o.output = Shapes::ShapeRef.new(shape: UpdateStreamWarmThroughputOutput)
+        o.errors << Shapes::ShapeRef.new(shape: AccessDeniedException)
+        o.errors << Shapes::ShapeRef.new(shape: ResourceNotFoundException)
+        o.errors << Shapes::ShapeRef.new(shape: LimitExceededException)
+        o.errors << Shapes::ShapeRef.new(shape: InvalidArgumentException)
+        o.errors << Shapes::ShapeRef.new(shape: ResourceInUseException)
+        o.errors << Shapes::ShapeRef.new(shape: ValidationException)
       end)
     end
 

data/lib/aws-sdk-kinesis/endpoints.rb

@@ -344,6 +344,16 @@ module Aws::Kinesis
       end
     end
 
+    class UpdateStreamWarmThroughput
+      def self.build(context)
+        Aws::Kinesis::EndpointParameters.create(
+          context.config,
+          stream_arn: context.params[:stream_arn],
+          operation_type: "control",
+        )
+      end
+    end
+
 
     def self.parameters_for_operation(context)
       case context.operation_name
@@ -413,6 +423,8 @@ module Aws::Kinesis
         UpdateShardCount.build(context)
       when :update_stream_mode
         UpdateStreamMode.build(context)
+      when :update_stream_warm_throughput
+        UpdateStreamWarmThroughput.build(context)
       else
         Aws::Kinesis::EndpointParameters.create(context.config)
       end

data/lib/aws-sdk-kinesis/types.rb

@@ -184,6 +184,12 @@ module Aws::Kinesis
     #   consists of a required key and an optional value.
     #   @return [Hash<String,String>]
     #
+    # @!attribute [rw] warm_throughput_mi_bps
+    #   The target warm throughput in MB/s that the stream should be scaled
+    #   to handle. This represents the throughput capacity that will be
+    #   immediately available for write operations.
+    #   @return [Integer]
+    #
     # @!attribute [rw] max_record_size_in_ki_b
     #   The maximum record size of a single record in kibibyte (KiB) that
     #   you can write to, and read from a stream.
@@ -196,6 +202,7 @@ module Aws::Kinesis
       :shard_count,
       :stream_mode_details,
       :tags,
+      :warm_throughput_mi_bps,
       :max_record_size_in_ki_b)
       SENSITIVE = []
       include Aws::Structure
@@ -297,6 +304,25 @@ module Aws::Kinesis
       include Aws::Structure
     end
 
+    # @api private
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DescribeAccountSettingsInput AWS API Documentation
+    #
+    class DescribeAccountSettingsInput < Aws::EmptyStructure; end
+
+    # @!attribute [rw] minimum_throughput_billing_commitment
+    #   The current configuration of the minimum throughput billing
+    #   commitment for your Amazon Web Services account.
+    #   @return [Types::MinimumThroughputBillingCommitmentOutput]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DescribeAccountSettingsOutput AWS API Documentation
+    #
+    class DescribeAccountSettingsOutput < Struct.new(
+      :minimum_throughput_billing_commitment)
+      SENSITIVE = []
+      include Aws::Structure
+    end
+
     # @api private
     #
     # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/DescribeLimitsInput AWS API Documentation
@@ -1438,6 +1464,67 @@ module Aws::Kinesis
       include Aws::Structure
     end
 
+    # Represents the request parameters for configuring minimum throughput
+    # billing commitment.
+    #
+    # <note markdown="1"> * Minimum throughput billing commitments provide cost savings on
+    #   on-demand data streams in exchange for committing to a minimum level
+    #   of throughput usage.
+    #
+    # * Commitments have a minimum duration of 24 hours that must be honored
+    #   before they can be disabled.
+    #
+    # * If you attempt to disable a commitment before the minimum commitment
+    #   period ends, the commitment will be scheduled for automatic disable
+    #   at the earliest allowed end time.
+    #
+    # * You can cancel a pending disable by enabling the commitment again
+    #   before the earliest allowed end time.
+    #
+    #  </note>
+    #
+    # @!attribute [rw] status
+    #   The desired status of the minimum throughput billing commitment.
+    #   @return [String]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/MinimumThroughputBillingCommitmentInput AWS API Documentation
+    #
+    class MinimumThroughputBillingCommitmentInput < Struct.new(
+      :status)
+      SENSITIVE = []
+      include Aws::Structure
+    end
+
+    # Represents the current status of minimum throughput billing commitment
+    # for an account.
+    #
+    # @!attribute [rw] status
+    #   The current status of the minimum throughput billing commitment.
+    #   @return [String]
+    #
+    # @!attribute [rw] started_at
+    #   The timestamp when the commitment was started.
+    #   @return [Time]
+    #
+    # @!attribute [rw] ended_at
+    #   The timestamp when the commitment was ended.
+    #   @return [Time]
+    #
+    # @!attribute [rw] earliest_allowed_end_at
+    #   The earliest timestamp when the commitment can be ended.
+    #   @return [Time]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/MinimumThroughputBillingCommitmentOutput AWS API Documentation
+    #
+    class MinimumThroughputBillingCommitmentOutput < Struct.new(
+      :status,
+      :started_at,
+      :ended_at,
+      :earliest_allowed_end_at)
+      SENSITIVE = []
+      include Aws::Structure
+    end
+
     # The request rate for the stream is too high, or the requested data is
     # too large for the available throughput. Reduce the frequency or size
     # of your requests. For more information, see [Streams Limits][1] in the
@@ -2335,6 +2422,12 @@ module Aws::Kinesis
     #   The number of enhanced fan-out consumers registered with the stream.
     #   @return [Integer]
     #
+    # @!attribute [rw] warm_throughput
+    #   The warm throughput in MB/s for the stream. This represents the
+    #   throughput capacity that will be immediately available for write
+    #   operations.
+    #   @return [Types::WarmThroughputObject]
+    #
     # @!attribute [rw] max_record_size_in_ki_b
     #   The maximum record size of a single record in kibibyte (KiB) that
     #   you can write to, and read from a stream.
@@ -2354,6 +2447,7 @@ module Aws::Kinesis
       :key_id,
       :open_shard_count,
       :consumer_count,
+      :warm_throughput,
       :max_record_size_in_ki_b)
       SENSITIVE = []
       include Aws::Structure
@@ -2559,6 +2653,32 @@ module Aws::Kinesis
       include Aws::Structure
     end
 
+    # @!attribute [rw] minimum_throughput_billing_commitment
+    #   Specifies the minimum throughput billing commitment configuration
+    #   for your account.
+    #   @return [Types::MinimumThroughputBillingCommitmentInput]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/UpdateAccountSettingsInput AWS API Documentation
+    #
+    class UpdateAccountSettingsInput < Struct.new(
+      :minimum_throughput_billing_commitment)
+      SENSITIVE = []
+      include Aws::Structure
+    end
+
+    # @!attribute [rw] minimum_throughput_billing_commitment
+    #   The updated configuration of the minimum throughput billing
+    #   commitment for your account.
+    #   @return [Types::MinimumThroughputBillingCommitmentOutput]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/UpdateAccountSettingsOutput AWS API Documentation
+    #
+    class UpdateAccountSettingsOutput < Struct.new(
+      :minimum_throughput_billing_commitment)
+      SENSITIVE = []
+      include Aws::Structure
+    end
+
     # @!attribute [rw] stream_arn
     #   The Amazon Resource Name (ARN) of the stream for the `MaxRecordSize`
     #   update.
@@ -2659,11 +2779,66 @@ module Aws::Kinesis
     #   for your data streams.
     #   @return [Types::StreamModeDetails]
     #
+    # @!attribute [rw] warm_throughput_mi_bps
+    #   The target warm throughput in MB/s that the stream should be scaled
+    #   to handle. This represents the throughput capacity that will be
+    #   immediately available for write operations. This field is only valid
+    #   when the stream mode is being updated to on-demand.
+    #   @return [Integer]
+    #
     # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/UpdateStreamModeInput AWS API Documentation
     #
     class UpdateStreamModeInput < Struct.new(
       :stream_arn,
-      :stream_mode_details)
+      :stream_mode_details,
+      :warm_throughput_mi_bps)
+      SENSITIVE = []
+      include Aws::Structure
+    end
+
+    # @!attribute [rw] stream_arn
+    #   The ARN of the stream to be updated.
+    #   @return [String]
+    #
+    # @!attribute [rw] stream_name
+    #   The name of the stream to be updated.
+    #   @return [String]
+    #
+    # @!attribute [rw] warm_throughput_mi_bps
+    #   The target warm throughput in MB/s that the stream should be scaled
+    #   to handle. This represents the throughput capacity that will be
+    #   immediately available for write operations.
+    #   @return [Integer]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/UpdateStreamWarmThroughputInput AWS API Documentation
+    #
+    class UpdateStreamWarmThroughputInput < Struct.new(
+      :stream_arn,
+      :stream_name,
+      :warm_throughput_mi_bps)
+      SENSITIVE = []
+      include Aws::Structure
+    end
+
+    # @!attribute [rw] stream_arn
+    #   The ARN of the stream that was updated.
+    #   @return [String]
+    #
+    # @!attribute [rw] stream_name
+    #   The name of the stream that was updated.
+    #   @return [String]
+    #
+    # @!attribute [rw] warm_throughput
+    #   Specifies the updated warm throughput configuration for your data
+    #   stream.
+    #   @return [Types::WarmThroughputObject]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/UpdateStreamWarmThroughputOutput AWS API Documentation
+    #
+    class UpdateStreamWarmThroughputOutput < Struct.new(
+      :stream_arn,
+      :stream_name,
+      :warm_throughput)
       SENSITIVE = []
       include Aws::Structure
     end
@@ -2683,6 +2858,29 @@ module Aws::Kinesis
       include Aws::Structure
     end
 
+    # Represents the warm throughput configuration on the stream. This is
+    # only present for On-Demand Kinesis Data Streams in accounts that have
+    # `MinimumThroughputBillingCommitment` enabled.
+    #
+    # @!attribute [rw] target_mi_bps
+    #   The target warm throughput value on the stream. This indicates that
+    #   the stream is currently scaling towards this target value.
+    #   @return [Integer]
+    #
+    # @!attribute [rw] current_mi_bps
+    #   The current warm throughput value on the stream. This is the write
+    #   throughput in MiBps that the stream is currently scaled to handle.
+    #   @return [Integer]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02/WarmThroughputObject AWS API Documentation
+    #
+    class WarmThroughputObject < Struct.new(
+      :target_mi_bps,
+      :current_mi_bps)
+      SENSITIVE = []
+      include Aws::Structure
+    end
+
     # This is a tagged union for all of the types of events an enhanced
     # fan-out consumer can receive over HTTP/2 after a call to
     # SubscribeToShard.

data/lib/aws-sdk-kinesis.rb

@@ -57,7 +57,7 @@ module Aws::Kinesis
   autoload :AsyncClient, 'aws-sdk-kinesis/async_client'
   autoload :EventStreams, 'aws-sdk-kinesis/event_streams'
 
-  GEM_VERSION = '1.90.0'
+  GEM_VERSION = '1.91.0'
 
 end
 

data/sig/client.rbs

@@ -98,6 +98,7 @@ module Aws
                              stream_mode: ("PROVISIONED" | "ON_DEMAND")
                            },
                            ?tags: Hash[::String, ::String],
+                           ?warm_throughput_mi_bps: ::Integer,
                            ?max_record_size_in_ki_b: ::Integer
                          ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                        | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
@@ -132,6 +133,15 @@ module Aws
                                       ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                                     | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
 
+      interface _DescribeAccountSettingsResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::DescribeAccountSettingsOutput]
+        def minimum_throughput_billing_commitment: () -> Types::MinimumThroughputBillingCommitmentOutput
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Kinesis/Client.html#describe_account_settings-instance_method
+      def describe_account_settings: (
+                                     ) -> _DescribeAccountSettingsResponseSuccess
+                                   | (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeAccountSettingsResponseSuccess
+
       interface _DescribeLimitsResponseSuccess
         include ::Seahorse::Client::_ResponseSuccess[Types::DescribeLimitsOutput]
         def shard_limit: () -> ::Integer
@@ -446,6 +456,18 @@ module Aws
                           ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                         | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
 
+      interface _UpdateAccountSettingsResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateAccountSettingsOutput]
+        def minimum_throughput_billing_commitment: () -> Types::MinimumThroughputBillingCommitmentOutput
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Kinesis/Client.html#update_account_settings-instance_method
+      def update_account_settings: (
+                                     minimum_throughput_billing_commitment: {
+                                       status: ("ENABLED" | "DISABLED")
+                                     }
+                                   ) -> _UpdateAccountSettingsResponseSuccess
+                                 | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateAccountSettingsResponseSuccess
+
       # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Kinesis/Client.html#update_max_record_size-instance_method
       def update_max_record_size: (
                                     ?stream_arn: ::String,
@@ -474,10 +496,25 @@ module Aws
                                 stream_arn: ::String,
                                 stream_mode_details: {
                                   stream_mode: ("PROVISIONED" | "ON_DEMAND")
-                                }
+                                },
+                                ?warm_throughput_mi_bps: ::Integer
                               ) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
                             | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> ::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]
 
+      interface _UpdateStreamWarmThroughputResponseSuccess
+        include ::Seahorse::Client::_ResponseSuccess[Types::UpdateStreamWarmThroughputOutput]
+        def stream_arn: () -> ::String
+        def stream_name: () -> ::String
+        def warm_throughput: () -> Types::WarmThroughputObject
+      end
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Kinesis/Client.html#update_stream_warm_throughput-instance_method
+      def update_stream_warm_throughput: (
+                                           ?stream_arn: ::String,
+                                           ?stream_name: ::String,
+                                           warm_throughput_mi_bps: ::Integer
+                                         ) -> _UpdateStreamWarmThroughputResponseSuccess
+                                       | (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _UpdateStreamWarmThroughputResponseSuccess
+
       # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Kinesis/Client.html#wait_until-instance_method
       def wait_until: (:stream_exists waiter_name, 
                     ?stream_name: ::String,

data/sig/types.rbs

@@ -49,6 +49,7 @@ module Aws::Kinesis
       attr_accessor shard_count: ::Integer
       attr_accessor stream_mode_details: Types::StreamModeDetails
       attr_accessor tags: ::Hash[::String, ::String]
+      attr_accessor warm_throughput_mi_bps: ::Integer
       attr_accessor max_record_size_in_ki_b: ::Integer
       SENSITIVE: []
     end
@@ -79,6 +80,14 @@ module Aws::Kinesis
       SENSITIVE: []
     end
 
+    class DescribeAccountSettingsInput < Aws::EmptyStructure
+    end
+
+    class DescribeAccountSettingsOutput
+      attr_accessor minimum_throughput_billing_commitment: Types::MinimumThroughputBillingCommitmentOutput
+      SENSITIVE: []
+    end
+
     class DescribeLimitsInput < Aws::EmptyStructure
     end
 
@@ -346,6 +355,19 @@ module Aws::Kinesis
       SENSITIVE: []
     end
 
+    class MinimumThroughputBillingCommitmentInput
+      attr_accessor status: ("ENABLED" | "DISABLED")
+      SENSITIVE: []
+    end
+
+    class MinimumThroughputBillingCommitmentOutput
+      attr_accessor status: ("ENABLED" | "DISABLED" | "ENABLED_UNTIL_EARLIEST_ALLOWED_END")
+      attr_accessor started_at: ::Time
+      attr_accessor ended_at: ::Time
+      attr_accessor earliest_allowed_end_at: ::Time
+      SENSITIVE: []
+    end
+
     class ProvisionedThroughputExceededException
       attr_accessor message: ::String
       SENSITIVE: []
@@ -523,6 +545,7 @@ module Aws::Kinesis
       attr_accessor key_id: ::String
       attr_accessor open_shard_count: ::Integer
       attr_accessor consumer_count: ::Integer
+      attr_accessor warm_throughput: Types::WarmThroughputObject
       attr_accessor max_record_size_in_ki_b: ::Integer
       SENSITIVE: []
     end
@@ -580,6 +603,16 @@ module Aws::Kinesis
       SENSITIVE: []
     end
 
+    class UpdateAccountSettingsInput
+      attr_accessor minimum_throughput_billing_commitment: Types::MinimumThroughputBillingCommitmentInput
+      SENSITIVE: []
+    end
+
+    class UpdateAccountSettingsOutput
+      attr_accessor minimum_throughput_billing_commitment: Types::MinimumThroughputBillingCommitmentOutput
+      SENSITIVE: []
+    end
+
     class UpdateMaxRecordSizeInput
       attr_accessor stream_arn: ::String
       attr_accessor max_record_size_in_ki_b: ::Integer
@@ -605,6 +638,21 @@ module Aws::Kinesis
     class UpdateStreamModeInput
       attr_accessor stream_arn: ::String
       attr_accessor stream_mode_details: Types::StreamModeDetails
+      attr_accessor warm_throughput_mi_bps: ::Integer
+      SENSITIVE: []
+    end
+
+    class UpdateStreamWarmThroughputInput
+      attr_accessor stream_arn: ::String
+      attr_accessor stream_name: ::String
+      attr_accessor warm_throughput_mi_bps: ::Integer
+      SENSITIVE: []
+    end
+
+    class UpdateStreamWarmThroughputOutput
+      attr_accessor stream_arn: ::String
+      attr_accessor stream_name: ::String
+      attr_accessor warm_throughput: Types::WarmThroughputObject
       SENSITIVE: []
     end
 
@@ -613,6 +661,12 @@ module Aws::Kinesis
       SENSITIVE: []
     end
 
+    class WarmThroughputObject
+      attr_accessor target_mi_bps: ::Integer
+      attr_accessor current_mi_bps: ::Integer
+      SENSITIVE: []
+    end
+
     class SubscribeToShardEventStream < Enumerator[untyped, untyped]
       def event_types: () -> [:subscribe_to_shard_event, :resource_not_found_exception, :resource_in_use_exception, :kms_disabled_exception, :kms_invalid_state_exception, :kms_access_denied_exception, :kms_not_found_exception, :kms_opt_in_required, :kms_throttling_exception, :internal_failure_exception]
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aws-sdk-kinesis
 version: !ruby/object:Gem::Version
-  version: 1.90.0
+  version: 1.91.0
 platform: ruby
 authors:
 - Amazon Web Services