Merge pull request #35 from alexgridx/dependabot/go_modules/github.com/aws/aws-sdk-go-v2/service/kinesis-1.27.8

Bump github.com/aws/aws-sdk-go-v2/service/kinesis from 1.27.4 to 1.27.8

go.mod

@@ -11,7 +11,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/credentials v1.17.16
 	github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue v1.13.14
 	github.com/aws/aws-sdk-go-v2/service/dynamodb v1.32.0
-	github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.4
+	github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.8
 	github.com/awslabs/kinesis-aggregation/go/v2 v2.0.0-20230808105340-e631fe742486
 	github.com/go-sql-driver/mysql v1.8.1
 	github.com/lib/pq v1.10.9

go.sum

@@ -42,8 +42,8 @@ github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.9.8/go.mod h
 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.9 h1:Wx0rlZoEJR7JwlSZcHnEa7CNjrSIyVxMFWGAaXy4fJY=
 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.9/go.mod h1:aVMHdE0aHO3v+f/iw01fmXV/5DbfQ3Bi9nN7nd9bE9Y=
 github.com/aws/aws-sdk-go-v2/service/kinesis v1.6.0/go.mod h1:9O7UG2pELnP0hq35+Gd7XDjOLBkg7tmgRQ0y14ZjoJI=
-github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.4 h1:Oe8awBiS/iitcsRJB5+DHa3iCxoA0KwJJf0JNrYMINY=
+github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.8 h1:U1X1JiulWfr3lyIpdx0YCVANbF2UoMVhfv3DiDKBKwc=
-github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.4/go.mod h1:RCZCSFbieSgNG1RKegO26opXV4EXyef/vNBVJsUyHuw=
+github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.8/go.mod h1:YxRRhvHMl4YR2OZR3369QQUc2iLqTc3KUCv9ayD8758=
 github.com/aws/aws-sdk-go-v2/service/sso v1.20.9 h1:aD7AGQhvPuAxlSUfo0CWU7s6FpkbyykMhGYMvlqTjVs=
 github.com/aws/aws-sdk-go-v2/service/sso v1.20.9/go.mod h1:c1qtZUWtygI6ZdvKppzCSXsDOq5I4luJPZ0Ud3juFCA=
 github.com/aws/aws-sdk-go-v2/service/ssooidc v1.24.3 h1:Pav5q3cA260Zqez42T9UhIlsd9QeypszRPwC9LdSSsQ=

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/CHANGELOG.md

@@ -1,3 +1,19 @@
+# v1.27.8 (2024-05-23)
+
+* No change notes available for this release.
+
+# v1.27.7 (2024-05-16)
+
+* **Dependency Update**: Updated to the latest SDK module versions
+
+# v1.27.6 (2024-05-15)
+
+* **Dependency Update**: Updated to the latest SDK module versions
+
+# v1.27.5 (2024-05-08)
+
+* **Bug Fix**: GoDoc improvement
+
 # v1.27.4 (2024-03-29)
 
 * **Dependency Update**: Updated to the latest SDK module versions

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_AddTagsToStream.go

@@ -12,12 +12,16 @@ import (
 )
 
 // Adds or updates tags for the specified Kinesis data stream. You can assign up
-// to 50 tags to a data stream. When invoking this API, you must use either the
+// to 50 tags to a data stream.
-// StreamARN or the StreamName parameter, or both. It is recommended that you use
+//
-// the StreamARN input parameter when you invoke this API. If tags have already
+// When invoking this API, you must use either the StreamARN or the StreamName
-// been assigned to the stream, AddTagsToStream overwrites any existing tags that
+// parameter, or both. It is recommended that you use the StreamARN input
-// correspond to the specified tag keys. AddTagsToStream has a limit of five
+// parameter when you invoke this API.
-// transactions per second per account.
+//
+// If tags have already been assigned to the stream, AddTagsToStream overwrites
+// any existing tags that correspond to the specified tag keys.
+//
+// AddTagsToStreamhas a limit of five transactions per second per account.
 func (c *Client) AddTagsToStream(ctx context.Context, params *AddTagsToStreamInput, optFns ...func(*Options)) (*AddTagsToStreamOutput, error) {
 	if params == nil {
 		params = &AddTagsToStreamInput{}

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_CreateStream.go

@@ -14,37 +14,47 @@ import (
 // Creates a Kinesis data stream. A stream captures and transports data records
 // that are continuously emitted from different data sources or producers.
 // Scale-out within a stream is explicitly supported by means of shards, which are
-// uniquely identified groups of data records in a stream. You can create your data
+// uniquely identified groups of data records in a stream.
-// stream using either on-demand or provisioned capacity mode. Data streams with an
+//
-// on-demand mode require no capacity planning and automatically scale to handle
+// You can create your data stream using either on-demand or provisioned capacity
-// gigabytes of write and read throughput per minute. With the on-demand mode,
+// mode. Data streams with an on-demand mode require no capacity planning and
-// Kinesis Data Streams automatically manages the shards in order to provide the
+// automatically scale to handle gigabytes of write and read throughput per minute.
-// necessary throughput. For the data streams with a provisioned mode, you must
+// With the on-demand mode, Kinesis Data Streams automatically manages the shards
-// specify the number of shards for the data stream. Each shard can support reads
+// in order to provide the necessary throughput. For the data streams with a
-// up to five transactions per second, up to a maximum data read total of 2 MiB per
+// provisioned mode, you must specify the number of shards for the data stream.
-// second. Each shard can support writes up to 1,000 records per second, up to a
+// Each shard can support reads up to five transactions per second, up to a maximum
-// maximum data write total of 1 MiB per second. If the amount of data input
+// data read total of 2 MiB per second. Each shard can support writes up to 1,000
-// increases or decreases, you can add or remove shards. The stream name identifies
+// records per second, up to a maximum data write total of 1 MiB per second. If the
-// the stream. The name is scoped to the Amazon Web Services account used by the
+// amount of data input increases or decreases, you can add or remove shards.
-// application. It is also scoped by Amazon Web Services Region. That is, two
+//
-// streams in two different accounts can have the same name, and two streams in the
+// The stream name identifies the stream. The name is scoped to the Amazon Web
-// same account, but in two different Regions, can have the same name. CreateStream
+// Services account used by the application. It is also scoped by Amazon Web
-// is an asynchronous operation. Upon receiving a CreateStream request, Kinesis
+// Services Region. That is, two streams in two different accounts can have the
-// Data Streams immediately returns and sets the stream status to CREATING . After
+// same name, and two streams in the same account, but in two different Regions,
-// the stream is created, Kinesis Data Streams sets the stream status to ACTIVE .
+// can have the same name.
-// You should perform read and write operations only on an ACTIVE stream. You
+//
-// receive a LimitExceededException when making a CreateStream request when you
+// CreateStream is an asynchronous operation. Upon receiving a CreateStream
-// try to do one of the following:
+// request, Kinesis Data Streams immediately returns and sets the stream status to
+// CREATING . After the stream is created, Kinesis Data Streams sets the stream
+// status to ACTIVE . You should perform read and write operations only on an
+// ACTIVE stream.
+//
+// You receive a LimitExceededException when making a CreateStream request when
+// you try to do one of the following:
+//
 //   - Have more than five streams in the CREATING state at any point in time.
+//
 //   - Create more shards than are authorized for your account.
 //
-// For the default shard limit for an Amazon Web Services account, see Amazon
+// For the default shard limit for an Amazon Web Services account, see [Amazon Kinesis Data Streams Limits] in the
-// Kinesis Data Streams Limits (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
+// Amazon Kinesis Data Streams Developer Guide. To increase this limit, [contact Amazon Web Services Support].
-// in the Amazon Kinesis Data Streams Developer Guide. To increase this limit,
+//
-// contact Amazon Web Services Support (https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html)
+// You can use DescribeStreamSummary to check the stream status, which is returned in StreamStatus .
-// . You can use DescribeStreamSummary to check the stream status, which is
+//
-// returned in StreamStatus . CreateStream has a limit of five transactions per
+// CreateStreamhas a limit of five transactions per second per account.
-// second per account.
+//
+// [contact Amazon Web Services Support]: https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html
+// [Amazon Kinesis Data Streams Limits]: https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html
 func (c *Client) CreateStream(ctx context.Context, params *CreateStreamInput, optFns ...func(*Options)) (*CreateStreamOutput, error) {
 	if params == nil {
 		params = &CreateStreamInput{}

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_DecreaseStreamRetentionPeriod.go

@@ -13,12 +13,15 @@ import (
 
 // Decreases the Kinesis data stream's retention period, which is the length of
 // time data records are accessible after they are added to the stream. The minimum
-// value of a stream's retention period is 24 hours. When invoking this API, you
+// value of a stream's retention period is 24 hours.
-// 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
+// When invoking this API, you must use either the StreamARN or the StreamName
-// API. This operation may result in lost data. For example, if the stream's
+// parameter, or both. It is recommended that you use the StreamARN input
-// retention period is 48 hours and is decreased to 24 hours, any data already in
+// parameter when you invoke this API.
-// the stream that is older than 24 hours is inaccessible.
+//
+// This operation may result in lost data. For example, if the stream's retention
+// period is 48 hours and is decreased to 24 hours, any data already in the stream
+// that is older than 24 hours is inaccessible.
 func (c *Client) DecreaseStreamRetentionPeriod(ctx context.Context, params *DecreaseStreamRetentionPeriodInput, optFns ...func(*Options)) (*DecreaseStreamRetentionPeriodOutput, error) {
 	if params == nil {
 		params = &DecreaseStreamRetentionPeriodInput{}

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_DeleteResourcePolicy.go

@@ -13,7 +13,9 @@ import (
 
 // Delete a policy for the specified data stream or consumer. Request patterns can
 // be one of the following:
+//
 //   - Data stream pattern: arn:aws.*:kinesis:.*:\d{12}:.*stream/\S+
+//
 //   - Consumer pattern:
 //     ^(arn):aws.*:kinesis:.*:\d{12}:.*stream\/[a-zA-Z0-9_.-]+\/consumer\/[a-zA-Z0-9_.-]+:[0-9]+
 func (c *Client) DeleteResourcePolicy(ctx context.Context, params *DeleteResourcePolicyInput, optFns ...func(*Options)) (*DeleteResourcePolicyOutput, error) {

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_DeleteStream.go

@@ -14,18 +14,27 @@ import (
 // Deletes a Kinesis data stream and all its shards and data. You must shut down
 // any applications that are operating on the stream before you delete the stream.
 // If an application attempts to operate on a deleted stream, it receives the
-// exception ResourceNotFoundException . When invoking this API, you must use
+// exception ResourceNotFoundException .
-// either the StreamARN or the StreamName parameter, or both. It is recommended
+//
-// that you use the StreamARN input parameter when you invoke this API. If the
+// When invoking this API, you must use either the StreamARN or the StreamName
-// stream is in the ACTIVE state, you can delete it. After a DeleteStream request,
+// parameter, or both. It is recommended that you use the StreamARN input
-// the specified stream is in the DELETING state until Kinesis Data Streams
+// parameter when you invoke this API.
-// completes the deletion. Note: Kinesis Data Streams might continue to accept data
+//
-// read and write operations, such as PutRecord , PutRecords , and GetRecords , on
+// If the stream is in the ACTIVE state, you can delete it. After a DeleteStream
-// a stream in the DELETING state until the stream deletion is complete. When you
+// request, the specified stream is in the DELETING state until Kinesis Data
-// delete a stream, any shards in that stream are also deleted, and any tags are
+// Streams completes the deletion.
-// dissociated from the stream. You can use the DescribeStreamSummary operation to
+//
-// check the state of the stream, which is returned in StreamStatus . DeleteStream
+// Note: Kinesis Data Streams might continue to accept data read and write
-// has a limit of five transactions per second per account.
+// operations, such as PutRecord, PutRecords, and GetRecords, on a stream in the DELETING state until the
+// stream deletion is complete.
+//
+// When you delete a stream, any shards in that stream are also deleted, and any
+// tags are dissociated from the stream.
+//
+// You can use the DescribeStreamSummary operation to check the state of the stream, which is returned
+// in StreamStatus .
+//
+// DeleteStreamhas a limit of five transactions per second per account.
 func (c *Client) DeleteStream(ctx context.Context, params *DeleteStreamInput, optFns ...func(*Options)) (*DeleteStreamOutput, error) {
 	if params == nil {
 		params = &DeleteStreamInput{}

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_DeregisterStreamConsumer.go

@@ -15,10 +15,11 @@ import (
 // ARN of the data stream and the name you gave the consumer when you registered
 // it. You may also provide all three parameters, as long as they don't conflict
 // with each other. If you don't know the name or ARN of the consumer that you want
-// to deregister, you can use the ListStreamConsumers operation to get a list of
+// to deregister, you can use the ListStreamConsumersoperation to get a list of the descriptions of
-// the descriptions of all the consumers that are currently registered with a given
+// all the consumers that are currently registered with a given data stream. The
-// data stream. The description of a consumer contains its name and ARN. This
+// description of a consumer contains its name and ARN.
-// operation has a limit of five transactions per second per stream.
+//
+// This operation has a limit of five transactions per second per stream.
 func (c *Client) DeregisterStreamConsumer(ctx context.Context, params *DeregisterStreamConsumerInput, optFns ...func(*Options)) (*DeregisterStreamConsumerOutput, error) {
 	if params == nil {
 		params = &DeregisterStreamConsumerInput{}
@@ -47,9 +48,9 @@ type DeregisterStreamConsumerInput struct {
 	ConsumerName *string
 
 	// The ARN of the Kinesis data stream that the consumer is registered with. For
-	// more information, see Amazon Resource Names (ARNs) and Amazon Web Services
+	// more information, see [Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces].
-	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams)
+	//
-	// .
+	// [Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces]: https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams
 	StreamARN *string
 
 	noSmithyDocumentSerde

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_DescribeLimits.go

@@ -10,9 +10,12 @@ import (
 	smithyhttp "github.com/aws/smithy-go/transport/http"
 )
 
-// Describes the shard limits and usage for the account. If you update your
+// Describes the shard limits and usage for the account.
-// account limits, the old limits might be returned for a few minutes. This
+//
-// operation has a limit of one transaction per second per account.
+// If you update your account limits, the old limits might be returned for a few
+// minutes.
+//
+// This operation has a limit of one transaction per second per account.
 func (c *Client) DescribeLimits(ctx context.Context, params *DescribeLimitsInput, optFns ...func(*Options)) (*DescribeLimitsOutput, error) {
 	if params == nil {
 		params = &DescribeLimitsInput{}

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_DescribeStream.go

@@ -17,26 +17,35 @@ import (
 	"time"
 )
 
-// Describes the specified Kinesis data stream. This API has been revised. It's
+// Describes the specified Kinesis data stream.
-// highly recommended that you use the DescribeStreamSummary API to get a
+//
-// summarized description of the specified Kinesis data stream and the ListShards
+// This API has been revised. It's highly recommended that you use the DescribeStreamSummary API to get
-// API to list the shards in a specified data stream and obtain information about
+// a summarized description of the specified Kinesis data stream and the ListShardsAPI to
-// each shard. When invoking this API, you must use either the StreamARN or the
+// list the shards in a specified data stream and obtain information about each
-// StreamName parameter, or both. It is recommended that you use the StreamARN
+// shard.
-// input parameter when you invoke this API. The information returned includes the
+//
-// stream name, Amazon Resource Name (ARN), creation time, enhanced metric
+// When invoking this API, you must use either the StreamARN or the StreamName
-// configuration, and shard map. The shard map is an array of shard objects. For
+// parameter, or both. It is recommended that you use the StreamARN input
-// each shard object, there is the hash key and sequence number ranges that the
+// parameter when you invoke this API.
-// shard spans, and the IDs of any earlier shards that played in a role in creating
+//
-// the shard. Every record ingested in the stream is identified by a sequence
+// The information returned includes the stream name, Amazon Resource Name (ARN),
-// number, which is assigned when the record is put into the stream. You can limit
+// creation time, enhanced metric configuration, and shard map. The shard map is an
-// the number of shards returned by each call. For more information, see
+// array of shard objects. For each shard object, there is the hash key and
-// Retrieving Shards from a Stream (https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-retrieve-shards.html)
+// sequence number ranges that the shard spans, and the IDs of any earlier shards
-// in the Amazon Kinesis Data Streams Developer Guide. There are no guarantees
+// that played in a role in creating the shard. Every record ingested in the stream
-// about the chronological order shards returned. To process shards in
+// is identified by a sequence number, which is assigned when the record is put
-// chronological order, use the ID of the parent shard to track the lineage to the
+// into the stream.
-// oldest shard. This operation has a limit of 10 transactions per second per
+//
-// account.
+// You can limit the number of shards returned by each call. For more information,
+// see [Retrieving Shards from a Stream]in the Amazon Kinesis Data Streams Developer Guide.
+//
+// There are no guarantees about the chronological order shards returned. To
+// process shards in chronological order, use the ID of the parent shard to track
+// the lineage to the oldest shard.
+//
+// This operation has a limit of 10 transactions per second per account.
+//
+// [Retrieving Shards from a Stream]: https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-retrieve-shards.html
 func (c *Client) DescribeStream(ctx context.Context, params *DescribeStreamInput, optFns ...func(*Options)) (*DescribeStreamOutput, error) {
 	if params == nil {
 		params = &DescribeStreamInput{}
@@ -55,11 +64,13 @@ func (c *Client) DescribeStream(ctx context.Context, params *DescribeStreamInput
 // Represents the input for DescribeStream .
 type DescribeStreamInput struct {
 
-	// The shard ID of the shard to start with. Specify this parameter to indicate
+	// The shard ID of the shard to start with.
-	// that you want to describe the stream starting with the shard whose ID
+	//
-	// immediately follows ExclusiveStartShardId . If you don't specify this parameter,
+	// Specify this parameter to indicate that you want to describe the stream
-	// the default behavior for DescribeStream is to describe the stream starting with
+	// starting with the shard whose ID immediately follows ExclusiveStartShardId .
-	// the first shard in the stream.
+	//
+	// If you don't specify this parameter, the default behavior for DescribeStream is
+	// to describe the stream starting with the first shard in the stream.
 	ExclusiveStartShardId *string
 
 	// The maximum number of shards to return in a single call. The default value is
@@ -212,12 +223,13 @@ type StreamExistsWaiterOptions struct {
 
 	// 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
+	// used by the waiter to decide if a state is retryable or a terminal state.
-	// 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
+	// By default service-modeled logic will populate this option. This option can
-	// state mutators.The function returns an error in case of a failure state. In case
+	// thus be used to define a custom waiter state with fall-back to service-modeled
-	// of retry state, this function returns a bool value of true and nil error, while
+	// waiter state mutators.The function returns an error in case of a failure state.
-	// in case of success it returns a bool value of false and nil error.
+	// 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, *DescribeStreamInput, *DescribeStreamOutput, error) (bool, error)
 }
 
@@ -383,12 +395,13 @@ type StreamNotExistsWaiterOptions struct {
 
 	// 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
+	// used by the waiter to decide if a state is retryable or a terminal state.
-	// 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
+	// By default service-modeled logic will populate this option. This option can
-	// state mutators.The function returns an error in case of a failure state. In case
+	// thus be used to define a custom waiter state with fall-back to service-modeled
-	// of retry state, this function returns a bool value of true and nil error, while
+	// waiter state mutators.The function returns an error in case of a failure state.
-	// in case of success it returns a bool value of false and nil error.
+	// 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, *DescribeStreamInput, *DescribeStreamOutput, error) (bool, error)
 }
 

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_DescribeStreamConsumer.go

@@ -16,12 +16,14 @@ import (
 // consumer. Alternatively, you can provide the ARN of the data stream and the name
 // you gave the consumer when you registered it. You may also provide all three
 // parameters, as long as they don't conflict with each other. If you don't know
-// the name or ARN of the consumer that you want to describe, you can use the
+// the name or ARN of the consumer that you want to describe, you can use the ListStreamConsumers
-// ListStreamConsumers operation to get a list of the descriptions of all the
+// operation to get a list of the descriptions of all the consumers that are
-// consumers that are currently registered with a given data stream. This operation
+// currently registered with a given data stream.
-// has a limit of 20 transactions per second per stream. When making a
+//
-// cross-account call with DescribeStreamConsumer , make sure to provide the ARN of
+// This operation has a limit of 20 transactions per second per stream.
-// the consumer.
+//
+// When making a cross-account call with DescribeStreamConsumer , make sure to
+// provide the ARN of the consumer.
 func (c *Client) DescribeStreamConsumer(ctx context.Context, params *DescribeStreamConsumerInput, optFns ...func(*Options)) (*DescribeStreamConsumerOutput, error) {
 	if params == nil {
 		params = &DescribeStreamConsumerInput{}
@@ -46,9 +48,9 @@ type DescribeStreamConsumerInput struct {
 	ConsumerName *string
 
 	// The ARN of the Kinesis data stream that the consumer is registered with. For
-	// more information, see Amazon Resource Names (ARNs) and Amazon Web Services
+	// more information, see [Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces].
-	// Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams)
+	//
-	// .
+	// [Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces]: https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams
 	StreamARN *string
 
 	noSmithyDocumentSerde

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_DescribeStreamSummary.go

@@ -13,11 +13,16 @@ import (
 )
 
 // Provides a summarized description of the specified Kinesis data stream without
-// the shard list. When invoking this API, you must use either the StreamARN or
+// the shard list.
-// the StreamName parameter, or both. It is recommended that you use the StreamARN
+//
-// input parameter when you invoke this API. The information returned includes the
+// When invoking this API, you must use either the StreamARN or the StreamName
-// stream name, Amazon Resource Name (ARN), status, record retention period,
+// parameter, or both. It is recommended that you use the StreamARN input
-// approximate creation time, monitoring, encryption details, and open shard count.
+// parameter when you invoke this API.
+//
+// The information returned includes the stream name, Amazon Resource Name (ARN),
+// status, record retention period, approximate creation time, monitoring,
+// encryption details, and open shard count.
+//
 // DescribeStreamSummaryhas a limit of 20 transactions per second per account.
 func (c *Client) DescribeStreamSummary(ctx context.Context, params *DescribeStreamSummaryInput, optFns ...func(*Options)) (*DescribeStreamSummaryOutput, error) {
 	if params == nil {

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_DisableEnhancedMonitoring.go

@@ -12,9 +12,11 @@ import (
 	smithyhttp "github.com/aws/smithy-go/transport/http"
 )
 
-// Disables enhanced monitoring. When invoking this API, you must use either the
+// Disables enhanced monitoring.
-// StreamARN or the StreamName parameter, or both. It is recommended that you use
+//
-// the StreamARN input parameter when you invoke this API.
+// 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.
 func (c *Client) DisableEnhancedMonitoring(ctx context.Context, params *DisableEnhancedMonitoringInput, optFns ...func(*Options)) (*DisableEnhancedMonitoringOutput, error) {
 	if params == nil {
 		params = &DisableEnhancedMonitoringInput{}
@@ -33,19 +35,30 @@ func (c *Client) DisableEnhancedMonitoring(ctx context.Context, params *DisableE
 // Represents the input for DisableEnhancedMonitoring.
 type DisableEnhancedMonitoringInput struct {
 
-	// List of shard-level metrics to disable. The following are the valid shard-level
+	// List of shard-level metrics to disable.
-	// metrics. The value " ALL " disables every metric.
+	//
+	// The following are the valid shard-level metrics. The value " ALL " disables
+	// every metric.
+	//
 	//   - IncomingBytes
+	//
 	//   - IncomingRecords
+	//
 	//   - OutgoingBytes
+	//
 	//   - OutgoingRecords
+	//
 	//   - WriteProvisionedThroughputExceeded
+	//
 	//   - ReadProvisionedThroughputExceeded
+	//
 	//   - IteratorAgeMilliseconds
+	//
 	//   - ALL
-	// For more information, see Monitoring the Amazon Kinesis Data Streams Service
+	//
-	// with Amazon CloudWatch (https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html)
+	// For more information, see [Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch] in the Amazon Kinesis Data Streams Developer Guide.
-	// in the Amazon Kinesis Data Streams Developer Guide.
+	//
+	// [Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch]: https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html
 	//
 	// This member is required.
 	ShardLevelMetrics []types.MetricsName
@@ -64,8 +77,7 @@ func (in *DisableEnhancedMonitoringInput) bindEndpointParams(p *EndpointParamete
 	p.OperationType = ptr.String("control")
 }
 
-// Represents the output for EnableEnhancedMonitoring and DisableEnhancedMonitoring
+// Represents the output for EnableEnhancedMonitoring and DisableEnhancedMonitoring.
-// .
 type DisableEnhancedMonitoringOutput struct {
 
 	// Represents the current state of the metrics that are in the enhanced state

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_EnableEnhancedMonitoring.go

@@ -12,8 +12,9 @@ import (
 	smithyhttp "github.com/aws/smithy-go/transport/http"
 )
 
-// Enables enhanced Kinesis data stream monitoring for shard-level metrics. When
+// Enables enhanced Kinesis data stream monitoring for shard-level metrics.
-// invoking this API, you must use either the StreamARN or the StreamName
+//
+// 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.
 func (c *Client) EnableEnhancedMonitoring(ctx context.Context, params *EnableEnhancedMonitoringInput, optFns ...func(*Options)) (*EnableEnhancedMonitoringOutput, error) {
@@ -34,19 +35,30 @@ func (c *Client) EnableEnhancedMonitoring(ctx context.Context, params *EnableEnh
 // Represents the input for EnableEnhancedMonitoring.
 type EnableEnhancedMonitoringInput struct {
 
-	// List of shard-level metrics to enable. The following are the valid shard-level
+	// List of shard-level metrics to enable.
-	// metrics. The value " ALL " enables every metric.
+	//
+	// The following are the valid shard-level metrics. The value " ALL " enables every
+	// metric.
+	//
 	//   - IncomingBytes
+	//
 	//   - IncomingRecords
+	//
 	//   - OutgoingBytes
+	//
 	//   - OutgoingRecords
+	//
 	//   - WriteProvisionedThroughputExceeded
+	//
 	//   - ReadProvisionedThroughputExceeded
+	//
 	//   - IteratorAgeMilliseconds
+	//
 	//   - ALL
-	// For more information, see Monitoring the Amazon Kinesis Data Streams Service
+	//
-	// with Amazon CloudWatch (https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html)
+	// For more information, see [Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch] in the Amazon Kinesis Data Streams Developer Guide.
-	// in the Amazon Kinesis Data Streams Developer Guide.
+	//
+	// [Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch]: https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html
 	//
 	// This member is required.
 	ShardLevelMetrics []types.MetricsName
@@ -65,8 +77,7 @@ func (in *EnableEnhancedMonitoringInput) bindEndpointParams(p *EndpointParameter
 	p.OperationType = ptr.String("control")
 }
 
-// Represents the output for EnableEnhancedMonitoring and DisableEnhancedMonitoring
+// Represents the output for EnableEnhancedMonitoring and DisableEnhancedMonitoring.
-// .
 type EnableEnhancedMonitoringOutput struct {
 
 	// Represents the current state of the metrics that are in the enhanced state

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_GetRecords.go

@@ -14,57 +14,69 @@ import (
 	smithyhttp "github.com/aws/smithy-go/transport/http"
 )
 
-// Gets data records from a Kinesis data stream's shard. When invoking this API,
+// Gets data records from a Kinesis data stream's shard.
-// 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
+// When invoking this API, you must use either the StreamARN or the StreamName
-// API. Specify a shard iterator using the ShardIterator parameter. The shard
+// parameter, or both. It is recommended that you use the StreamARN input
-// iterator specifies the position in the shard from which you want to start
+// parameter when you invoke this API.
-// reading data records sequentially. If there are no records available in the
+//
-// portion of the shard that the iterator points to, GetRecords returns an empty
+// Specify a shard iterator using the ShardIterator parameter. The shard iterator
-// list. It might take multiple calls to get to a portion of the shard that
+// specifies the position in the shard from which you want to start reading data
-// contains records. You can scale by provisioning multiple shards per stream while
+// records sequentially. If there are no records available in the portion of the
-// considering service limits (for more information, see Amazon Kinesis Data
+// shard that the iterator points to, GetRecordsreturns an empty list. It might take
-// Streams Limits (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
+// multiple calls to get to a portion of the shard that contains records.
-// in the Amazon Kinesis Data Streams Developer Guide). Your application should
+//
-// have one thread per shard, each reading continuously from its stream. To read
+// You can scale by provisioning multiple shards per stream while considering
-// from a stream continually, call GetRecords in a loop. Use GetShardIterator to
+// service limits (for more information, see [Amazon Kinesis Data Streams Limits]in the Amazon Kinesis Data Streams
-// get the shard iterator to specify in the first GetRecords call. GetRecords
+// Developer Guide). Your application should have one thread per shard, each
+// reading continuously from its stream. To read from a stream continually, call GetRecords
+// in a loop. Use GetShardIteratorto get the shard iterator to specify in the first GetRecords call. GetRecords
 // returns a new shard iterator in NextShardIterator . Specify the shard iterator
-// returned in NextShardIterator in subsequent calls to GetRecords . If the shard
+// returned in NextShardIterator in subsequent calls to GetRecords. If the shard has been
-// has been closed, the shard iterator can't return more data and GetRecords
+// closed, the shard iterator can't return more data and GetRecordsreturns null in
-// returns null in NextShardIterator . You can terminate the loop when the shard is
+// NextShardIterator . You can terminate the loop when the shard is closed, or when
-// closed, or when the shard iterator reaches the record with the sequence number
+// the shard iterator reaches the record with the sequence number or other
-// or other attribute that marks it as the last record to process. Each data record
+// attribute that marks it as the last record to process.
-// can be up to 1 MiB in size, and each shard can read up to 2 MiB per second. You
+//
-// can ensure that your calls don't exceed the maximum supported size or throughput
+// Each data record can be up to 1 MiB in size, and each shard can read up to 2
-// by using the Limit parameter to specify the maximum number of records that
+// MiB per second. You can ensure that your calls don't exceed the maximum
-// GetRecords can return. Consider your average record size when determining this
+// supported size or throughput by using the Limit parameter to specify the
-// limit. The maximum number of records that can be returned per call is 10,000.
+// maximum number of records that GetRecordscan return. Consider your average record size
-// The size of the data returned by GetRecords varies depending on the utilization
+// when determining this limit. The maximum number of records that can be returned
-// of the shard. It is recommended that consumer applications retrieve records via
+// per call is 10,000.
-// the GetRecords command using the 5 TPS limit to remain caught up. Retrieving
+//
-// records less frequently can lead to consumer applications falling behind. The
+// The size of the data returned by GetRecords varies depending on the utilization of the
-// maximum size of data that GetRecords can return is 10 MiB. If a call returns
+// shard. It is recommended that consumer applications retrieve records via the
-// this amount of data, subsequent calls made within the next 5 seconds throw
+// GetRecords command using the 5 TPS limit to remain caught up. Retrieving records
+// less frequently can lead to consumer applications falling behind. The maximum
+// size of data that GetRecordscan return is 10 MiB. If a call returns this amount of data,
+// subsequent calls made within the next 5 seconds throw
 // ProvisionedThroughputExceededException . If there is insufficient provisioned
 // throughput on the stream, subsequent calls made within the next 1 second throw
-// ProvisionedThroughputExceededException . GetRecords doesn't return any data
+// ProvisionedThroughputExceededException . GetRecords doesn't return any data when it
-// when it throws an exception. For this reason, we recommend that you wait 1
+// throws an exception. For this reason, we recommend that you wait 1 second
-// second between calls to GetRecords . However, it's possible that the application
+// between calls to GetRecords. However, it's possible that the application will get
-// will get exceptions for longer than 1 second. To detect whether the application
+// exceptions for longer than 1 second.
-// is falling behind in processing, you can use the MillisBehindLatest response
+//
-// attribute. You can also monitor the stream using CloudWatch metrics and other
+// To detect whether the application is falling behind in processing, you can use
-// mechanisms (see Monitoring (https://docs.aws.amazon.com/kinesis/latest/dev/monitoring.html)
+// the MillisBehindLatest response attribute. You can also monitor the stream
-// in the Amazon Kinesis Data Streams Developer Guide). Each Amazon Kinesis record
+// using CloudWatch metrics and other mechanisms (see [Monitoring]in the Amazon Kinesis Data
-// includes a value, ApproximateArrivalTimestamp , that is set when a stream
+// Streams Developer Guide).
-// successfully receives and stores a record. This is commonly referred to as a
+//
-// server-side time stamp, whereas a client-side time stamp is set when a data
+// Each Amazon Kinesis record includes a value, ApproximateArrivalTimestamp , that
-// producer creates or sends the record to a stream (a data producer is any data
+// is set when a stream successfully receives and stores a record. This is commonly
-// source putting data records into a stream, for example with PutRecords ). The
+// referred to as a server-side time stamp, whereas a client-side time stamp is set
+// when a data producer creates or sends the record to a stream (a data producer is
+// any data source putting data records into a stream, for example with PutRecords). The
 // time stamp has millisecond precision. There are no guarantees about the time
 // stamp accuracy, or that the time stamp is always increasing. For example,
 // records in a shard or across a stream might have time stamps that are out of
-// order. This operation has a limit of five transactions per second per shard.
+// order.
+//
+// This operation has a limit of five transactions per second per shard.
+//
+// [Amazon Kinesis Data Streams Limits]: https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html
+// [Monitoring]: https://docs.aws.amazon.com/kinesis/latest/dev/monitoring.html
 func (c *Client) GetRecords(ctx context.Context, params *GetRecordsInput, optFns ...func(*Options)) (*GetRecordsOutput, error) {
 	if params == nil {
 		params = &GetRecordsInput{}
@@ -91,8 +103,8 @@ type GetRecordsInput struct {
 	ShardIterator *string
 
 	// The maximum number of records to return. Specify a value of up to 10,000. If
-	// you specify a value that is greater than 10,000, GetRecords throws
+	// you specify a value that is greater than 10,000, GetRecordsthrows InvalidArgumentException
-	// InvalidArgumentException . The default value is 10,000.
+	// . The default value is 10,000.
 	Limit *int32
 
 	// The ARN of the stream.
@@ -118,8 +130,8 @@ type GetRecordsOutput struct {
 	// response only when the end of the current shard is reached.
 	ChildShards []types.ChildShard
 
-	// The number of milliseconds the GetRecords response is from the tip of the
+	// The number of milliseconds the GetRecords response is from the tip of the stream,
-	// stream, indicating how far behind current time the consumer is. A value of zero
+	// indicating how far behind current time the consumer is. A value of zero
 	// indicates that record processing is caught up, and there are no new records to
 	// process at this moment.
 	MillisBehindLatest *int64

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_GetResourcePolicy.go

@@ -13,7 +13,9 @@ import (
 
 // Returns a policy attached to the specified data stream or consumer. Request
 // patterns can be one of the following:
+//
 //   - Data stream pattern: arn:aws.*:kinesis:.*:\d{12}:.*stream/\S+
+//
 //   - Consumer pattern:
 //     ^(arn):aws.*:kinesis:.*:\d{12}:.*stream\/[a-zA-Z0-9_.-]+\/consumer\/[a-zA-Z0-9_.-]+:[0-9]+
 func (c *Client) GetResourcePolicy(ctx context.Context, params *GetResourcePolicyInput, optFns ...func(*Options)) (*GetResourcePolicyOutput, error) {

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_GetShardIterator.go

@@ -14,37 +14,45 @@ import (
 )
 
 // Gets an Amazon Kinesis shard iterator. A shard iterator expires 5 minutes after
-// it is returned to the requester. When invoking this API, you must use either the
+// it is returned to the requester.
-// StreamARN or the StreamName parameter, or both. It is recommended that you use
+//
-// the StreamARN input parameter when you invoke this API. A shard iterator
+// When invoking this API, you must use either the StreamARN or the StreamName
-// specifies the shard position from which to start reading data records
+// parameter, or both. It is recommended that you use the StreamARN input
-// sequentially. The position is specified using the sequence number of a data
+// parameter when you invoke this API.
-// record in a shard. A sequence number is the identifier associated with every
+//
-// record ingested in the stream, and is assigned when a record is put into the
+// A shard iterator specifies the shard position from which to start reading data
-// stream. Each stream has one or more shards. You must specify the shard iterator
+// records sequentially. The position is specified using the sequence number of a
-// type. For example, you can set the ShardIteratorType parameter to read exactly
+// data record in a shard. A sequence number is the identifier associated with
-// from the position denoted by a specific sequence number by using the
+// every record ingested in the stream, and is assigned when a record is put into
-// AT_SEQUENCE_NUMBER shard iterator type. Alternatively, the parameter can read
+// the stream. Each stream has one or more shards.
-// right after the sequence number by using the AFTER_SEQUENCE_NUMBER shard
+//
-// iterator type, using sequence numbers returned by earlier calls to PutRecord ,
+// You must specify the shard iterator type. For example, you can set the
-// PutRecords , GetRecords , or DescribeStream . In the request, you can specify
+// ShardIteratorType parameter to read exactly from the position denoted by a
-// the shard iterator type AT_TIMESTAMP to read records from an arbitrary point in
+// specific sequence number by using the AT_SEQUENCE_NUMBER shard iterator type.
-// time, TRIM_HORIZON to cause ShardIterator to point to the last untrimmed record
+// Alternatively, the parameter can read right after the sequence number by using
-// in the shard in the system (the oldest data record in the shard), or LATEST so
+// the AFTER_SEQUENCE_NUMBER shard iterator type, using sequence numbers returned
-// that you always read the most recent data in the shard. When you read repeatedly
+// by earlier calls to PutRecord, PutRecords, GetRecords, or DescribeStream. In the request, you can specify the shard
-// from a stream, use a GetShardIterator request to get the first shard iterator
+// iterator type AT_TIMESTAMP to read records from an arbitrary point in time,
-// for use in your first GetRecords request and for subsequent reads use the shard
+// TRIM_HORIZON to cause ShardIterator to point to the last untrimmed record in
-// iterator returned by the GetRecords request in NextShardIterator . A new shard
+// the shard in the system (the oldest data record in the shard), or LATEST so
-// iterator is returned by every GetRecords request in NextShardIterator , which
+// that you always read the most recent data in the shard.
-// you use in the ShardIterator parameter of the next GetRecords request. If a
+//
-// GetShardIterator request is made too often, you receive a
+// When you read repeatedly from a stream, use a GetShardIterator request to get the first shard
+// iterator for use in your first GetRecordsrequest and for subsequent reads use the shard
+// iterator returned by the GetRecordsrequest in NextShardIterator . A new shard iterator is
+// returned by every GetRecordsrequest in NextShardIterator , which you use in the
+// ShardIterator parameter of the next GetRecords request.
+//
+// If a GetShardIterator request is made too often, you receive a
 // ProvisionedThroughputExceededException . For more information about throughput
-// limits, see GetRecords , and Streams Limits (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
+// limits, see GetRecords, and [Streams Limits] in the Amazon Kinesis Data Streams Developer Guide.
-// in the Amazon Kinesis Data Streams Developer Guide. If the shard is closed,
+//
-// GetShardIterator returns a valid iterator for the last sequence number of the
+// If the shard is closed, GetShardIterator returns a valid iterator for the last sequence number
-// shard. A shard can be closed as a result of using SplitShard or MergeShards .
+// of the shard. A shard can be closed as a result of using SplitShardor MergeShards.
-// GetShardIterator has a limit of five transactions per second per account per
+//
-// open shard.
+// GetShardIteratorhas a limit of five transactions per second per account per open shard.
+//
+// [Streams Limits]: https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html
 func (c *Client) GetShardIterator(ctx context.Context, params *GetShardIteratorInput, optFns ...func(*Options)) (*GetShardIteratorOutput, error) {
 	if params == nil {
 		params = &GetShardIteratorInput{}
@@ -69,15 +77,22 @@ type GetShardIteratorInput struct {
 	ShardId *string
 
 	// Determines how the shard iterator is used to start reading data records from
-	// the shard. The following are the valid Amazon Kinesis shard iterator types:
+	// the shard.
+	//
+	// The following are the valid Amazon Kinesis shard iterator types:
+	//
 	//   - AT_SEQUENCE_NUMBER - Start reading from the position denoted by a specific
 	//   sequence number, provided in the value StartingSequenceNumber .
+	//
 	//   - AFTER_SEQUENCE_NUMBER - Start reading right after the position denoted by a
 	//   specific sequence number, provided in the value StartingSequenceNumber .
+	//
 	//   - AT_TIMESTAMP - Start reading from the position denoted by a specific time
 	//   stamp, provided in the value Timestamp .
+	//
 	//   - TRIM_HORIZON - Start reading at the last untrimmed record in the shard in
 	//   the system, which is the oldest data record in the shard.
+	//
 	//   - LATEST - Start reading just after the most recent record in the shard, so
 	//   that you always read the most recent data in the shard.
 	//

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_IncreaseStreamRetentionPeriod.go

@@ -13,16 +13,19 @@ import (
 
 // Increases the Kinesis data stream's retention period, which is the length of
 // time data records are accessible after they are added to the stream. The maximum
-// value of a stream's retention period is 8760 hours (365 days). When invoking
+// value of a stream's retention period is 8760 hours (365 days).
-// 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
+// When invoking this API, you must use either the StreamARN or the StreamName
-// invoke this API. If you choose a longer stream retention period, this operation
+// parameter, or both. It is recommended that you use the StreamARN input
-// increases the time period during which records that have not yet expired are
+// parameter when you invoke this API.
-// accessible. However, it does not make previous, expired data (older than the
+//
-// stream's previous retention period) accessible after the operation has been
+// If you choose a longer stream retention period, this operation increases the
-// called. For example, if a stream's retention period is set to 24 hours and is
+// time period during which records that have not yet expired are accessible.
-// increased to 168 hours, any data that is older than 24 hours remains
+// However, it does not make previous, expired data (older than the stream's
-// inaccessible to consumer applications.
+// previous retention period) accessible after the operation has been called. For
+// example, if a stream's retention period is set to 24 hours and is increased to
+// 168 hours, any data that is older than 24 hours remains inaccessible to consumer
+// applications.
 func (c *Client) IncreaseStreamRetentionPeriod(ctx context.Context, params *IncreaseStreamRetentionPeriodInput, optFns ...func(*Options)) (*IncreaseStreamRetentionPeriodOutput, error) {
 	if params == nil {
 		params = &IncreaseStreamRetentionPeriodInput{}

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_ListShards.go

@@ -14,18 +14,22 @@ import (
 )
 
 // Lists the shards in a stream and provides information about each shard. This
-// operation has a limit of 1000 transactions per second per data stream. When
+// operation has a limit of 1000 transactions per second per data stream.
-// invoking this API, you must use either the StreamARN or the StreamName
+//
+// 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. This action does not list expired shards.
+// parameter when you invoke this API.
-// For information about expired shards, see Data Routing, Data Persistence, and
+//
-// Shard State after a Reshard (https://docs.aws.amazon.com/streams/latest/dev/kinesis-using-sdk-java-after-resharding.html#kinesis-using-sdk-java-resharding-data-routing)
+// This action does not list expired shards. For information about expired shards,
-// . This API is a new operation that is used by the Amazon Kinesis Client Library
+// see [Data Routing, Data Persistence, and Shard State after a Reshard].
+//
+// This API is a new operation that is used by the Amazon Kinesis Client Library
 // (KCL). If you have a fine-grained IAM policy that only allows specific
 // operations, you must update your policy to allow calls to this API. For more
-// information, see Controlling Access to Amazon Kinesis Data Streams Resources
+// information, see [Controlling Access to Amazon Kinesis Data Streams Resources Using IAM].
-// Using IAM (https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html)
+//
-// .
+// [Data Routing, Data Persistence, and Shard State after a Reshard]: https://docs.aws.amazon.com/streams/latest/dev/kinesis-using-sdk-java-after-resharding.html#kinesis-using-sdk-java-resharding-data-routing
+// [Controlling Access to Amazon Kinesis Data Streams Resources Using IAM]: https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html
 func (c *Client) ListShards(ctx context.Context, params *ListShardsInput, optFns ...func(*Options)) (*ListShardsOutput, error) {
 	if params == nil {
 		params = &ListShardsInput{}
@@ -44,15 +48,18 @@ func (c *Client) ListShards(ctx context.Context, params *ListShardsInput, optFns
 type ListShardsInput struct {
 
 	// Specify this parameter to indicate that you want to list the shards starting
-	// with the shard whose ID immediately follows ExclusiveStartShardId . If you don't
+	// with the shard whose ID immediately follows ExclusiveStartShardId .
-	// specify this parameter, the default behavior is for ListShards to list the
+	//
-	// shards starting with the first one in the stream. You cannot specify this
+	// If you don't specify this parameter, the default behavior is for ListShards to
-	// parameter if you specify NextToken .
+	// list the shards starting with the first one in the stream.
+	//
+	// You cannot specify this parameter if you specify NextToken .
 	ExclusiveStartShardId *string
 
 	// The maximum number of shards to return in a single call to ListShards . The
 	// maximum number of shards to return in a single call. The default value is 1000.
 	// If you specify a value greater than 1000, at most 1000 results are returned.
+	//
 	// When the number of shards to be listed is greater than the value of MaxResults ,
 	// the response contains a NextToken value that you can use in a subsequent call
 	// to ListShards to list the next set of shards.
@@ -63,33 +70,42 @@ type ListShardsInput struct {
 	// MaxResults that is less than the number of shards in the data stream, the
 	// response includes a pagination token named NextToken . You can specify this
 	// NextToken value in a subsequent call to ListShards to list the next set of
-	// shards. Don't specify StreamName or StreamCreationTimestamp if you specify
+	// shards.
-	// NextToken because the latter unambiguously identifies the stream. You can
+	//
-	// optionally specify a value for the MaxResults parameter when you specify
+	// Don't specify StreamName or StreamCreationTimestamp if you specify NextToken
-	// NextToken . If you specify a MaxResults value that is less than the number of
+	// because the latter unambiguously identifies the stream.
-	// shards that the operation returns if you don't specify MaxResults , the response
+	//
-	// will contain a new NextToken value. You can use the new NextToken value in a
+	// You can optionally specify a value for the MaxResults parameter when you
-	// subsequent call to the ListShards operation. Tokens expire after 300 seconds.
+	// specify NextToken . If you specify a MaxResults value that is less than the
-	// When you obtain a value for NextToken in the response to a call to ListShards ,
+	// number of shards that the operation returns if you don't specify MaxResults ,
-	// you have 300 seconds to use that value. If you specify an expired token in a
+	// the response will contain a new NextToken value. You can use the new NextToken
-	// call to ListShards , you get ExpiredNextTokenException .
+	// value in a subsequent call to the ListShards operation.
+	//
+	// Tokens expire after 300 seconds. When you obtain a value for NextToken in the
+	// response to a call to ListShards , you have 300 seconds to use that value. If
+	// you specify an expired token in a call to ListShards , you get
+	// ExpiredNextTokenException .
 	NextToken *string
 
 	// Enables you to filter out the response of the ListShards API. You can only
-	// specify one filter at a time. If you use the ShardFilter parameter when
+	// specify one filter at a time.
-	// invoking the ListShards API, the Type is the required property and must be
+	//
-	// specified. If you specify the AT_TRIM_HORIZON , FROM_TRIM_HORIZON , or AT_LATEST
+	// If you use the ShardFilter parameter when invoking the ListShards API, the Type
-	// types, you do not need to specify either the ShardId or the Timestamp optional
+	// is the required property and must be specified. If you specify the
-	// properties. If you specify the AFTER_SHARD_ID type, you must also provide the
+	// AT_TRIM_HORIZON , FROM_TRIM_HORIZON , or AT_LATEST types, you do not need to
-	// value for the optional ShardId property. The ShardId property is identical in
+	// specify either the ShardId or the Timestamp optional properties.
-	// fuctionality to the ExclusiveStartShardId parameter of the ListShards API. When
+	//
-	// ShardId property is specified, the response includes the shards starting with
+	// If you specify the AFTER_SHARD_ID type, you must also provide the value for the
-	// the shard whose ID immediately follows the ShardId that you provided. If you
+	// optional ShardId property. The ShardId property is identical in fuctionality to
-	// specify the AT_TIMESTAMP or FROM_TIMESTAMP_ID type, you must also provide the
+	// the ExclusiveStartShardId parameter of the ListShards API. When ShardId
-	// value for the optional Timestamp property. If you specify the AT_TIMESTAMP
+	// property is specified, the response includes the shards starting with the shard
-	// type, then all shards that were open at the provided timestamp are returned. If
+	// whose ID immediately follows the ShardId that you provided.
-	// you specify the FROM_TIMESTAMP type, then all shards starting from the provided
+	//
-	// timestamp to TIP are returned.
+	// If you specify the AT_TIMESTAMP or FROM_TIMESTAMP_ID type, you must also
+	// provide the value for the optional Timestamp property. If you specify the
+	// AT_TIMESTAMP type, then all shards that were open at the provided timestamp are
+	// returned. If you specify the FROM_TIMESTAMP type, then all shards starting from
+	// the provided timestamp to TIP are returned.
 	ShardFilter *types.ShardFilter
 
 	// The ARN of the stream.
@@ -98,12 +114,14 @@ type ListShardsInput struct {
 	// Specify this input parameter to distinguish data streams that have the same
 	// name. For example, if you create a data stream and then delete it, and you later
 	// create another data stream with the same name, you can use this input parameter
-	// to specify which of the two streams you want to list the shards for. You cannot
+	// to specify which of the two streams you want to list the shards for.
-	// specify this parameter if you specify the NextToken parameter.
+	//
+	// You cannot specify this parameter if you specify the NextToken parameter.
 	StreamCreationTimestamp *time.Time
 
-	// The name of the data stream whose shards you want to list. You cannot specify
+	// The name of the data stream whose shards you want to list.
-	// this parameter if you specify the NextToken parameter.
+	//
+	// You cannot specify this parameter if you specify the NextToken parameter.
 	StreamName *string
 
 	noSmithyDocumentSerde
@@ -122,10 +140,12 @@ type ListShardsOutput struct {
 	// response includes a pagination token named NextToken . You can specify this
 	// NextToken value in a subsequent call to ListShards to list the next set of
 	// shards. For more information about the use of this pagination token when calling
-	// the ListShards operation, see ListShardsInput$NextToken . Tokens expire after
+	// the ListShards operation, see ListShardsInput$NextToken.
-	// 300 seconds. When you obtain a value for NextToken in the response to a call to
+	//
-	// ListShards , you have 300 seconds to use that value. If you specify an expired
+	// Tokens expire after 300 seconds. When you obtain a value for NextToken in the
-	// token in a call to ListShards , you get ExpiredNextTokenException .
+	// response to a call to ListShards , you have 300 seconds to use that value. If
+	// you specify an expired token in a call to ListShards , you get
+	// ExpiredNextTokenException .
 	NextToken *string
 
 	// An array of JSON objects. Each object represents one shard and specifies the

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_ListStreamConsumers.go

@@ -14,8 +14,9 @@ import (
 )
 
 // Lists the consumers registered to receive data from a stream using enhanced
-// fan-out, and provides information about each consumer. This operation has a
+// fan-out, and provides information about each consumer.
-// limit of 5 transactions per second per stream.
+//
+// This operation has a limit of 5 transactions per second per stream.
 func (c *Client) ListStreamConsumers(ctx context.Context, params *ListStreamConsumersInput, optFns ...func(*Options)) (*ListStreamConsumersOutput, error) {
 	if params == nil {
 		params = &ListStreamConsumersInput{}
@@ -34,9 +35,9 @@ func (c *Client) ListStreamConsumers(ctx context.Context, params *ListStreamCons
 type ListStreamConsumersInput struct {
 
 	// The ARN of the Kinesis data stream for which you want to list the registered
-	// consumers. For more information, see Amazon Resource Names (ARNs) and Amazon
+	// consumers. For more information, see [Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces].
-	// Web Services Service Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams)
+	//
-	// .
+	// [Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces]: https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams
 	//
 	// This member is required.
 	StreamARN *string
@@ -52,24 +53,30 @@ type ListStreamConsumersInput struct {
 	// consumers that are registered with the data stream, the response includes a
 	// pagination token named NextToken . You can specify this NextToken value in a
 	// subsequent call to ListStreamConsumers to list the next set of registered
-	// consumers. Don't specify StreamName or StreamCreationTimestamp if you specify
+	// consumers.
-	// NextToken because the latter unambiguously identifies the stream. You can
+	//
-	// optionally specify a value for the MaxResults parameter when you specify
+	// Don't specify StreamName or StreamCreationTimestamp if you specify NextToken
-	// NextToken . If you specify a MaxResults value that is less than the number of
+	// because the latter unambiguously identifies the stream.
-	// consumers that the operation returns if you don't specify MaxResults , the
+	//
-	// response will contain a new NextToken value. You can use the new NextToken
+	// You can optionally specify a value for the MaxResults parameter when you
+	// specify NextToken . If you specify a MaxResults value that is less than the
+	// number of consumers that the operation returns if you don't specify MaxResults ,
+	// the response will contain a new NextToken value. You can use the new NextToken
 	// value in a subsequent call to the ListStreamConsumers operation to list the
-	// next set of consumers. Tokens expire after 300 seconds. When you obtain a value
+	// next set of consumers.
-	// for NextToken in the response to a call to ListStreamConsumers , you have 300
+	//
-	// seconds to use that value. If you specify an expired token in a call to
+	// Tokens expire after 300 seconds. When you obtain a value for NextToken in the
-	// ListStreamConsumers , you get ExpiredNextTokenException .
+	// response to a call to ListStreamConsumers , you have 300 seconds to use that
+	// value. If you specify an expired token in a call to ListStreamConsumers , you
+	// get ExpiredNextTokenException .
 	NextToken *string
 
 	// Specify this input parameter to distinguish data streams that have the same
 	// name. For example, if you create a data stream and then delete it, and you later
 	// create another data stream with the same name, you can use this input parameter
-	// to specify which of the two streams you want to list the consumers for. You
+	// to specify which of the two streams you want to list the consumers for.
-	// can't specify this parameter if you specify the NextToken parameter.
+	//
+	// You can't specify this parameter if you specify the NextToken parameter.
 	StreamCreationTimestamp *time.Time
 
 	noSmithyDocumentSerde
@@ -91,11 +98,12 @@ type ListStreamConsumersOutput struct {
 	// registered consumers, the response includes a pagination token named NextToken .
 	// You can specify this NextToken value in a subsequent call to ListStreamConsumers
 	// to list the next set of registered consumers. For more information about the use
-	// of this pagination token when calling the ListStreamConsumers operation, see
+	// of this pagination token when calling the ListStreamConsumers operation, see ListStreamConsumersInput$NextToken.
-	// ListStreamConsumersInput$NextToken . Tokens expire after 300 seconds. When you
+	//
-	// obtain a value for NextToken in the response to a call to ListStreamConsumers ,
+	// Tokens expire after 300 seconds. When you obtain a value for NextToken in the
-	// you have 300 seconds to use that value. If you specify an expired token in a
+	// response to a call to ListStreamConsumers , you have 300 seconds to use that
-	// call to ListStreamConsumers , you get ExpiredNextTokenException .
+	// value. If you specify an expired token in a call to ListStreamConsumers , you
+	// get ExpiredNextTokenException .
 	NextToken *string
 
 	// Metadata pertaining to the operation's result.

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_ListStreams.go

@@ -11,18 +11,22 @@ import (
 	smithyhttp "github.com/aws/smithy-go/transport/http"
 )
 
-// Lists your Kinesis data streams. The number of streams may be too large to
+// Lists your Kinesis data streams.
-// return from a single call to ListStreams . You can limit the number of returned
+//
-// streams using the Limit parameter. If you do not specify a value for the Limit
+// The number of streams may be too large to return from a single call to
-// parameter, Kinesis Data Streams uses the default limit, which is currently 100.
+// ListStreams . You can limit the number of returned streams using the Limit
+// parameter. If you do not specify a value for the Limit parameter, Kinesis Data
+// Streams uses the default limit, which is currently 100.
+//
 // You can detect if there are more streams available to list by using the
 // HasMoreStreams flag from the returned output. If there are more streams
 // available, you can request more streams by using the name of the last stream
 // returned by the ListStreams request in the ExclusiveStartStreamName parameter
 // in a subsequent request to ListStreams . The group of stream names returned by
 // the subsequent request is then added to the list. You can continue this process
-// until all the stream names have been collected in the list. ListStreams has a
+// until all the stream names have been collected in the list.
-// limit of five transactions per second per account.
+//
+// ListStreamshas a limit of five transactions per second per account.
 func (c *Client) ListStreams(ctx context.Context, params *ListStreamsInput, optFns ...func(*Options)) (*ListStreamsOutput, error) {
 	if params == nil {
 		params = &ListStreamsInput{}

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_ListTagsForStream.go

@@ -13,9 +13,11 @@ import (
 )
 
 // Lists the tags for the specified Kinesis data stream. This operation has a
-// limit of five transactions per second per account. When invoking this API, you
+// limit of five transactions per second per account.
-// 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.
+// 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.
 func (c *Client) ListTagsForStream(ctx context.Context, params *ListTagsForStreamInput, optFns ...func(*Options)) (*ListTagsForStreamOutput, error) {
 	if params == nil {
 		params = &ListTagsForStreamInput{}

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_MergeShards.go

@@ -20,28 +20,39 @@ import (
 // range of 382...454, then you could merge these two shards into a single shard
 // that would have a hash key range of 276...454. After the merge, the single child
 // shard receives data for all hash key values covered by the two parent shards.
+//
 // 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. MergeShards is called when there is a need
+// parameter when you invoke this API.
-// to reduce the overall capacity of a stream because of excess capacity that is
+//
-// not being used. You must specify the shard to be merged and the adjacent shard
+// MergeShards is called when there is a need to reduce the overall capacity of a
-// for a stream. For more information about merging shards, see Merge Two Shards (https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-merge.html)
+// stream because of excess capacity that is not being used. You must specify the
-// in the Amazon Kinesis Data Streams Developer Guide. If the stream is in the
+// shard to be merged and the adjacent shard for a stream. For more information
-// ACTIVE state, you can call MergeShards . If a stream is in the CREATING ,
+// about merging shards, see [Merge Two Shards]in the Amazon Kinesis Data Streams Developer Guide.
-// UPDATING , or DELETING state, MergeShards returns a ResourceInUseException . If
+//
-// the specified stream does not exist, MergeShards returns a
+// If the stream is in the ACTIVE state, you can call MergeShards . If a stream is
-// ResourceNotFoundException . You can use DescribeStreamSummary to check the
+// in the CREATING , UPDATING , or DELETING state, MergeShards returns a
-// state of the stream, which is returned in StreamStatus . MergeShards is an
+// ResourceInUseException . If the specified stream does not exist, MergeShards
-// asynchronous operation. Upon receiving a MergeShards request, Amazon Kinesis
+// returns a ResourceNotFoundException .
-// Data Streams immediately returns a response and sets the StreamStatus to
+//
-// UPDATING . After the operation is completed, Kinesis Data Streams sets the
+// You can use DescribeStreamSummary to check the state of the stream, which is returned in StreamStatus
-// StreamStatus to ACTIVE . Read and write operations continue to work while the
+// .
-// stream is in the UPDATING state. You use DescribeStreamSummary and the
+//
-// ListShards APIs to determine the shard IDs that are specified in the MergeShards
+// MergeShards is an asynchronous operation. Upon receiving a MergeShards request,
-// request. If you try to operate on too many streams in parallel using
+// Amazon Kinesis Data Streams immediately returns a response and sets the
-// CreateStream , DeleteStream , MergeShards , or SplitShard , you receive a
+// StreamStatus to UPDATING . After the operation is completed, Kinesis Data
-// LimitExceededException . MergeShards has a limit of five transactions per
+// Streams sets the StreamStatus to ACTIVE . Read and write operations continue to
-// second per account.
+// work while the stream is in the UPDATING state.
+//
+// You use DescribeStreamSummary and the ListShards APIs to determine the shard IDs that are specified in the
+// MergeShards request.
+//
+// If you try to operate on too many streams in parallel using CreateStream, DeleteStream, MergeShards , or SplitShard
+// , you receive a LimitExceededException .
+//
+// MergeShards has a limit of five transactions per second per account.
+//
+// [Merge Two Shards]: https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-merge.html
 func (c *Client) MergeShards(ctx context.Context, params *MergeShardsInput, optFns ...func(*Options)) (*MergeShardsOutput, error) {
 	if params == nil {
 		params = &MergeShardsInput{}

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_PutRecord.go

@@ -15,38 +15,51 @@ import (
 // Writes a single data record into an Amazon Kinesis data stream. Call PutRecord
 // to send data into the stream for real-time ingestion and subsequent processing,
 // one record at a time. Each shard can support writes up to 1,000 records per
-// second, up to a maximum data write total of 1 MiB per second. When invoking this
+// second, up to a maximum data write total of 1 MiB per second.
-// 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
+// When invoking this API, you must use either the StreamARN or the StreamName
-// API. You must specify the name of the stream that captures, stores, and
+// parameter, or both. It is recommended that you use the StreamARN input
-// transports the data; a partition key; and the data blob itself. The data blob
+// parameter when you invoke this API.
-// can be any type of data; for example, a segment from a log file,
+//
-// geographic/location data, website clickstream data, and so on. The partition key
+// You must specify the name of the stream that captures, stores, and transports
-// is used by Kinesis Data Streams to distribute data across shards. Kinesis Data
+// the data; a partition key; and the data blob itself.
-// Streams segregates the data records that belong to a stream into multiple
+//
-// shards, using the partition key associated with each data record to determine
+// The data blob can be any type of data; for example, a segment from a log file,
-// the shard to which a given data record belongs. Partition keys are Unicode
+// geographic/location data, website clickstream data, and so on.
-// strings, with a maximum length limit of 256 characters for each key. An MD5 hash
+//
-// function is used to map partition keys to 128-bit integer values and to map
+// The partition key is used by Kinesis Data Streams to distribute data across
-// associated data records to shards using the hash key ranges of the shards. You
+// shards. Kinesis Data Streams segregates the data records that belong to a stream
-// can override hashing the partition key to determine the shard by explicitly
+// into multiple shards, using the partition key associated with each data record
-// specifying a hash value using the ExplicitHashKey parameter. For more
+// to determine the shard to which a given data record belongs.
-// information, see Adding Data to a Stream (https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-stream)
+//
-// in the Amazon Kinesis Data Streams Developer Guide. PutRecord returns the shard
+// Partition keys are Unicode strings, with a maximum length limit of 256
-// ID of where the data record was placed and the sequence number that was assigned
+// characters for each key. An MD5 hash function is used to map partition keys to
-// to the data record. Sequence numbers increase over time and are specific to a
+// 128-bit integer values and to map associated data records to shards using the
-// shard within a stream, not across all shards within a stream. To guarantee
+// hash key ranges of the shards. You can override hashing the partition key to
-// strictly increasing ordering, write serially to a shard and use the
+// determine the shard by explicitly specifying a hash value using the
-// SequenceNumberForOrdering parameter. For more information, see Adding Data to a
+// ExplicitHashKey parameter. For more information, see [Adding Data to a Stream] in the Amazon Kinesis
-// Stream (https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-stream)
+// Data Streams Developer Guide.
-// in the Amazon Kinesis Data Streams Developer Guide. After you write a record to
+//
-// a stream, you cannot modify that record or its order within the stream. If a
+// PutRecord returns the shard ID of where the data record was placed and the
-// PutRecord request cannot be processed because of insufficient provisioned
+// sequence number that was assigned to the data record.
+//
+// Sequence numbers increase over time and are specific to a shard within a
+// stream, not across all shards within a stream. To guarantee strictly increasing
+// ordering, write serially to a shard and use the SequenceNumberForOrdering
+// parameter. For more information, see [Adding Data to a Stream]in the Amazon Kinesis Data Streams
+// Developer Guide.
+//
+// After you write a record to a stream, you cannot modify that record or its
+// order within the stream.
+//
+// If a PutRecord request cannot be processed because of insufficient provisioned
 // throughput on the shard involved in the request, PutRecord throws
-// ProvisionedThroughputExceededException . By default, data records are accessible
+// ProvisionedThroughputExceededException .
-// for 24 hours from the time that they are added to a stream. You can use
+//
-// IncreaseStreamRetentionPeriod or DecreaseStreamRetentionPeriod to modify this
+// By default, data records are accessible for 24 hours from the time that they
-// retention period.
+// are added to a stream. You can use IncreaseStreamRetentionPeriodor DecreaseStreamRetentionPeriod to modify this retention period.
+//
+// [Adding Data to a Stream]: https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-stream
 func (c *Client) PutRecord(ctx context.Context, params *PutRecordInput, optFns ...func(*Options)) (*PutRecordOutput, error) {
 	if params == nil {
 		params = &PutRecordInput{}
@@ -128,7 +141,9 @@ type PutRecordOutput struct {
 
 	// The encryption type to use on the record. This parameter can be one of the
 	// following values:
+	//
 	//   - NONE : Do not encrypt the records in the stream.
+	//
 	//   - KMS : Use server-side encryption on the records in the stream using a
 	//   customer-managed Amazon Web Services KMS key.
 	EncryptionType types.EncryptionType

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_PutRecords.go

@@ -14,56 +14,74 @@ import (
 
 // Writes multiple data records into a Kinesis data stream in a single call (also
 // referred to as a PutRecords request). Use this operation to send data into the
-// stream for data ingestion and processing. When invoking this API, you must use
+// stream for data ingestion and processing.
-// either the StreamARN or the StreamName parameter, or both. It is recommended
+//
-// that you use the StreamARN input parameter when you invoke this API. Each
+// When invoking this API, you must use either the StreamARN or the StreamName
-// PutRecords request can support up to 500 records. Each record in the request can
+// parameter, or both. It is recommended that you use the StreamARN input
-// be as large as 1 MiB, up to a limit of 5 MiB for the entire request, including
+// parameter when you invoke this API.
-// partition keys. Each shard can support writes up to 1,000 records per second, up
+//
-// to a maximum data write total of 1 MiB per second. You must specify the name of
+// Each PutRecords request can support up to 500 records. Each record in the
-// the stream that captures, stores, and transports the data; and an array of
+// request can be as large as 1 MiB, up to a limit of 5 MiB for the entire request,
-// request Records , with each record in the array requiring a partition key and
+// including partition keys. Each shard can support writes up to 1,000 records per
-// data blob. The record size limit applies to the total size of the partition key
+// second, up to a maximum data write total of 1 MiB per second.
-// and data blob. The data blob can be any type of data; for example, a segment
+//
-// from a log file, geographic/location data, website clickstream data, and so on.
+// You must specify the name of the stream that captures, stores, and transports
+// the data; and an array of request Records , with each record in the array
+// requiring a partition key and data blob. The record size limit applies to the
+// total size of the partition key and data blob.
+//
+// The data blob can be any type of data; for example, a segment from a log file,
+// geographic/location data, website clickstream data, and so on.
+//
 // The partition key is used by Kinesis Data Streams as input to a hash function
 // that maps the partition key and associated data to a specific shard. An MD5 hash
 // function is used to map partition keys to 128-bit integer values and to map
 // associated data records to shards. As a result of this hashing mechanism, all
 // data records with the same partition key map to the same shard within the
-// stream. For more information, see Adding Data to a Stream (https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-stream)
+// stream. For more information, see [Adding Data to a Stream]in the Amazon Kinesis Data Streams Developer
-// in the Amazon Kinesis Data Streams Developer Guide. Each record in the Records
+// Guide.
-// array may include an optional parameter, ExplicitHashKey , which overrides the
+//
-// partition key to shard mapping. This parameter allows a data producer to
+// Each record in the Records array may include an optional parameter,
-// determine explicitly the shard where the record is stored. For more information,
+// ExplicitHashKey , which overrides the partition key to shard mapping. This
-// see Adding Multiple Records with PutRecords (https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-putrecords)
+// parameter allows a data producer to determine explicitly the shard where the
-// in the Amazon Kinesis Data Streams Developer Guide. The PutRecords response
+// record is stored. For more information, see [Adding Multiple Records with PutRecords]in the Amazon Kinesis Data Streams
-// includes an array of response Records . Each record in the response array
+// Developer Guide.
-// directly correlates with a record in the request array using natural ordering,
+//
-// from the top to the bottom of the request and response. The response Records
+// The PutRecords response includes an array of response Records . Each record in
-// array always includes the same number of records as the request array. The
+// the response array directly correlates with a record in the request array using
-// response Records array includes both successfully and unsuccessfully processed
+// natural ordering, from the top to the bottom of the request and response. The
-// records. Kinesis Data Streams attempts to process all records in each PutRecords
+// response Records array always includes the same number of records as the
-// request. A single record failure does not stop the processing of subsequent
+// request array.
-// records. As a result, PutRecords doesn't guarantee the ordering of records. If
+//
-// you need to read records in the same order they are written to the stream, use
+// The response Records array includes both successfully and unsuccessfully
-// PutRecord instead of PutRecords , and write to the same shard. A successfully
+// processed records. Kinesis Data Streams attempts to process all records in each
-// processed record includes ShardId and SequenceNumber values. The ShardId
+// PutRecords request. A single record failure does not stop the processing of
-// parameter identifies the shard in the stream where the record is stored. The
+// subsequent records. As a result, PutRecords doesn't guarantee the ordering of
-// SequenceNumber parameter is an identifier assigned to the put record, unique to
+// records. If you need to read records in the same order they are written to the
-// all records in the stream. An unsuccessfully processed record includes ErrorCode
+// stream, use PutRecordinstead of PutRecords , and write to the same shard.
-// and ErrorMessage values. ErrorCode reflects the type of error and can be one of
+//
-// the following values: ProvisionedThroughputExceededException or InternalFailure
+// A successfully processed record includes ShardId and SequenceNumber values. The
-// . ErrorMessage provides more detailed information about the
+// ShardId parameter identifies the shard in the stream where the record is stored.
+// The SequenceNumber parameter is an identifier assigned to the put record,
+// unique to all records in the stream.
+//
+// An unsuccessfully processed record includes ErrorCode and ErrorMessage values.
+// ErrorCode reflects the type of error and can be one of the following values:
+// ProvisionedThroughputExceededException or InternalFailure . ErrorMessage
+// provides more detailed information about the
 // ProvisionedThroughputExceededException exception including the account ID,
 // stream name, and shard ID of the record that was throttled. For more information
-// about partially successful responses, see Adding Multiple Records with
+// about partially successful responses, see [Adding Multiple Records with PutRecords]in the Amazon Kinesis Data Streams
-// PutRecords (https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-add-data-to-stream.html#kinesis-using-sdk-java-putrecords)
+// Developer Guide.
-// in the Amazon Kinesis Data Streams Developer Guide. After you write a record to
+//
-// a stream, you cannot modify that record or its order within the stream. By
+// After you write a record to a stream, you cannot modify that record or its
-// default, data records are accessible for 24 hours from the time that they are
+// order within the stream.
-// added to a stream. You can use IncreaseStreamRetentionPeriod or
+//
-// DecreaseStreamRetentionPeriod to modify this retention period.
+// By default, data records are accessible for 24 hours from the time that they
+// are added to a stream. You can use IncreaseStreamRetentionPeriodor DecreaseStreamRetentionPeriod to modify this retention period.
+//
+// [Adding Multiple Records with PutRecords]: https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-add-data-to-stream.html#kinesis-using-sdk-java-putrecords
+// [Adding Data to a Stream]: https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-stream
 func (c *Client) PutRecords(ctx context.Context, params *PutRecordsInput, optFns ...func(*Options)) (*PutRecordsOutput, error) {
 	if params == nil {
 		params = &PutRecordsInput{}
@@ -114,7 +132,9 @@ type PutRecordsOutput struct {
 
 	// The encryption type used on the records. This parameter can be one of the
 	// following values:
+	//
 	//   - NONE : Do not encrypt the records.
+	//
 	//   - KMS : Use server-side encryption on the records using a customer-managed
 	//   Amazon Web Services KMS key.
 	EncryptionType types.EncryptionType

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_PutResourcePolicy.go

@@ -18,15 +18,18 @@ import (
 // belong to the owner's account in order to use this operation. If you don't have
 // PutResourcePolicy permissions, Amazon Kinesis Data Streams returns a 403 Access
 // Denied error . If you receive a ResourceNotFoundException , check to see if you
-// passed a valid stream or consumer resource. Request patterns can be one of the
+// passed a valid stream or consumer resource.
-// following:
+//
+// Request patterns can be one of the following:
+//
 //   - Data stream pattern: arn:aws.*:kinesis:.*:\d{12}:.*stream/\S+
+//
 //   - Consumer pattern:
 //     ^(arn):aws.*:kinesis:.*:\d{12}:.*stream\/[a-zA-Z0-9_.-]+\/consumer\/[a-zA-Z0-9_.-]+:[0-9]+
 //
-// For more information, see Controlling Access to Amazon Kinesis Data Streams
+// For more information, see [Controlling Access to Amazon Kinesis Data Streams Resources Using IAM].
-// Resources Using IAM (https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html)
+//
-// .
+// [Controlling Access to Amazon Kinesis Data Streams Resources Using IAM]: https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html
 func (c *Client) PutResourcePolicy(ctx context.Context, params *PutResourcePolicyInput, optFns ...func(*Options)) (*PutResourcePolicyOutput, error) {
 	if params == nil {
 		params = &PutResourcePolicyInput{}

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_RegisterStreamConsumer.go

@@ -13,17 +13,21 @@ import (
 )
 
 // Registers a consumer with a Kinesis data stream. When you use this operation,
-// the consumer you register can then call SubscribeToShard to receive data from
+// the consumer you register can then call SubscribeToShardto receive data from the stream using
-// the stream using enhanced fan-out, at a rate of up to 2 MiB per second for every
+// enhanced fan-out, at a rate of up to 2 MiB per second for every shard you
-// shard you subscribe to. This rate is unaffected by the total number of consumers
+// subscribe to. This rate is unaffected by the total number of consumers that read
-// that read from the same stream. You can register up to 20 consumers per stream.
+// from the same stream.
-// A given consumer can only be registered with one stream at a time. For an
+//
-// example of how to use this operations, see Enhanced Fan-Out Using the Kinesis
+// You can register up to 20 consumers per stream. A given consumer can only be
-// Data Streams API . The use of this operation has a limit of five transactions
+// registered with one stream at a time.
-// per second per account. Also, only 5 consumers can be created simultaneously. In
+//
-// other words, you cannot have more than 5 consumers in a CREATING status at the
+// For an example of how to use this operations, see Enhanced Fan-Out Using the Kinesis Data Streams API.
-// same time. Registering a 6th consumer while there are 5 in a CREATING status
+//
-// results in a LimitExceededException .
+// The use of this operation has a limit of five transactions per second per
+// account. Also, only 5 consumers can be created simultaneously. In other words,
+// you cannot have more than 5 consumers in a CREATING status at the same time.
+// Registering a 6th consumer while there are 5 in a CREATING status results in a
+// LimitExceededException .
 func (c *Client) RegisterStreamConsumer(ctx context.Context, params *RegisterStreamConsumerInput, optFns ...func(*Options)) (*RegisterStreamConsumerOutput, error) {
 	if params == nil {
 		params = &RegisterStreamConsumerInput{}
@@ -48,9 +52,9 @@ type RegisterStreamConsumerInput struct {
 	ConsumerName *string
 
 	// The ARN of the Kinesis data stream that you want to register the consumer with.
-	// For more info, see Amazon Resource Names (ARNs) and Amazon Web Services Service
+	// For more info, see [Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces].
-	// Namespaces (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams)
+	//
-	// .
+	// [Amazon Resource Names (ARNs) and Amazon Web Services Service Namespaces]: https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-kinesis-streams
 	//
 	// This member is required.
 	StreamARN *string

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_RemoveTagsFromStream.go

@@ -12,12 +12,15 @@ import (
 )
 
 // Removes tags from the specified Kinesis data stream. Removed tags are deleted
-// and cannot be recovered after this operation successfully completes. When
+// and cannot be recovered after this operation successfully completes.
-// invoking this API, you must use either the StreamARN or the StreamName
+//
+// 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. If you specify a tag that does not exist, it
+// parameter when you invoke this API.
-// is ignored. RemoveTagsFromStream has a limit of five transactions per second
+//
-// per account.
+// If you specify a tag that does not exist, it is ignored.
+//
+// RemoveTagsFromStreamhas a limit of five transactions per second per account.
 func (c *Client) RemoveTagsFromStream(ctx context.Context, params *RemoveTagsFromStreamInput, optFns ...func(*Options)) (*RemoveTagsFromStreamOutput, error) {
 	if params == nil {
 		params = &RemoveTagsFromStreamInput{}

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_SplitShard.go

@@ -15,40 +15,52 @@ import (
 // stream's capacity to ingest and transport data. SplitShard is called when there
 // is a need to increase the overall capacity of a stream because of an expected
 // increase in the volume of data records being ingested. This API is only
-// supported for the data streams with the provisioned capacity mode. When invoking
+// supported for the data streams with the provisioned capacity mode.
-// 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
+// When invoking this API, you must use either the StreamARN or the StreamName
-// invoke this API. You can also use SplitShard when a shard appears to be
+// parameter, or both. It is recommended that you use the StreamARN input
-// approaching its maximum utilization; for example, the producers sending data
+// parameter when you invoke this API.
-// into the specific shard are suddenly sending more than previously anticipated.
+//
-// You can also call SplitShard to increase stream capacity, so that more Kinesis
+// You can also use SplitShard when a shard appears to be approaching its maximum
-// Data Streams applications can simultaneously read data from the stream for
+// utilization; for example, the producers sending data into the specific shard are
-// real-time processing. You must specify the shard to be split and the new hash
+// suddenly sending more than previously anticipated. You can also call SplitShard
-// key, which is the position in the shard where the shard gets split in two. In
+// to increase stream capacity, so that more Kinesis Data Streams applications can
-// many cases, the new hash key might be the average of the beginning and ending
+// simultaneously read data from the stream for real-time processing.
-// hash key, but it can be any hash key value in the range being mapped into the
+//
-// shard. For more information, see Split a Shard (https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-split.html)
+// You must specify the shard to be split and the new hash key, which is the
-// in the Amazon Kinesis Data Streams Developer Guide. You can use
+// position in the shard where the shard gets split in two. In many cases, the new
-// DescribeStreamSummary and the ListShards APIs to determine the shard ID and
+// hash key might be the average of the beginning and ending hash key, but it can
-// hash key values for the ShardToSplit and NewStartingHashKey parameters that are
+// be any hash key value in the range being mapped into the shard. For more
-// specified in the SplitShard request. SplitShard is an asynchronous operation.
+// information, see [Split a Shard]in the Amazon Kinesis Data Streams Developer Guide.
-// Upon receiving a SplitShard request, Kinesis Data Streams immediately returns a
+//
-// response and sets the stream status to UPDATING . After the operation is
+// You can use DescribeStreamSummary and the ListShards APIs to determine the shard ID and hash key values for
-// completed, Kinesis Data Streams sets the stream status to ACTIVE . Read and
+// the ShardToSplit and NewStartingHashKey parameters that are specified in the
-// write operations continue to work while the stream is in the UPDATING state.
+// SplitShard request.
-// You can use DescribeStreamSummary to check the status of the stream, which is
+//
-// returned in StreamStatus . If the stream is in the ACTIVE state, you can call
+// SplitShard is an asynchronous operation. Upon receiving a SplitShard request,
-// SplitShard . If the specified stream does not exist, DescribeStreamSummary
+// Kinesis Data Streams immediately returns a response and sets the stream status
-// returns a ResourceNotFoundException . If you try to create more shards than are
+// to UPDATING . After the operation is completed, Kinesis Data Streams sets the
-// authorized for your account, you receive a LimitExceededException . For the
+// stream status to ACTIVE . Read and write operations continue to work while the
-// default shard limit for an Amazon Web Services account, see Kinesis Data
+// stream is in the UPDATING state.
-// Streams Limits (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
+//
-// in the Amazon Kinesis Data Streams Developer Guide. To increase this limit,
+// You can use DescribeStreamSummary to check the status of the stream, which is returned in
-// contact Amazon Web Services Support (https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html)
+// StreamStatus . If the stream is in the ACTIVE state, you can call SplitShard .
-// . If you try to operate on too many streams simultaneously using CreateStream ,
+//
-// DeleteStream , MergeShards , and/or SplitShard , you receive a
+// If the specified stream does not exist, DescribeStreamSummary returns a ResourceNotFoundException .
-// LimitExceededException . SplitShard has a limit of five transactions per second
+// If you try to create more shards than are authorized for your account, you
-// per account.
+// receive a LimitExceededException .
+//
+// For the default shard limit for an Amazon Web Services account, see [Kinesis Data Streams Limits] in the
+// Amazon Kinesis Data Streams Developer Guide. To increase this limit, [contact Amazon Web Services Support].
+//
+// If you try to operate on too many streams simultaneously using CreateStream, DeleteStream, MergeShards, and/or SplitShard,
+// you receive a LimitExceededException .
+//
+// SplitShard has a limit of five transactions per second per account.
+//
+// [Kinesis Data Streams Limits]: https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html
+// [contact Amazon Web Services Support]: https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html
+// [Split a Shard]: https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-split.html
 func (c *Client) SplitShard(ctx context.Context, params *SplitShardInput, optFns ...func(*Options)) (*SplitShardOutput, error) {
 	if params == nil {
 		params = &SplitShardInput{}

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_StartStreamEncryption.go

@@ -13,22 +13,27 @@ import (
 )
 
 // Enables or updates server-side encryption using an Amazon Web Services KMS key
-// for a specified stream. When invoking this API, you must use either the
+// for a specified stream.
-// StreamARN or the StreamName parameter, or both. It is recommended that you use
+//
-// the StreamARN input parameter when you invoke this API. Starting encryption is
+// When invoking this API, you must use either the StreamARN or the StreamName
-// an asynchronous operation. Upon receiving the request, Kinesis Data Streams
+// parameter, or both. It is recommended that you use the StreamARN input
-// returns immediately and sets the status of the stream to UPDATING . After the
+// parameter when you invoke this API.
-// update is complete, Kinesis Data Streams sets the status of the stream back to
+//
-// ACTIVE . Updating or applying encryption normally takes a few seconds to
+// Starting encryption is an asynchronous operation. Upon receiving the request,
-// complete, but it can take minutes. You can continue to read and write data to
+// Kinesis Data Streams returns immediately and sets the status of the stream to
-// your stream while its status is UPDATING . Once the status of the stream is
+// UPDATING . After the update is complete, Kinesis Data Streams sets the status of
-// ACTIVE , encryption begins for records written to the stream. API Limits: You
+// the stream back to ACTIVE . Updating or applying encryption normally takes a few
-// can successfully apply a new Amazon Web Services KMS key for server-side
+// seconds to complete, but it can take minutes. You can continue to read and write
-// encryption 25 times in a rolling 24-hour period. Note: It can take up to 5
+// data to your stream while its status is UPDATING . Once the status of the stream
-// seconds after the stream is in an ACTIVE status before all records written to
+// is ACTIVE , encryption begins for records written to the stream.
-// the stream are encrypted. After you enable encryption, you can verify that
+//
-// encryption is applied by inspecting the API response from PutRecord or
+// API Limits: You can successfully apply a new Amazon Web Services KMS key for
-// PutRecords .
+// server-side encryption 25 times in a rolling 24-hour period.
+//
+// Note: It can take up to 5 seconds after the stream is in an ACTIVE status
+// before all records written to the stream are encrypted. After you enable
+// encryption, you can verify that encryption is applied by inspecting the API
+// response from PutRecord or PutRecords .
 func (c *Client) StartStreamEncryption(ctx context.Context, params *StartStreamEncryptionInput, optFns ...func(*Options)) (*StartStreamEncryptionOutput, error) {
 	if params == nil {
 		params = &StartStreamEncryptionInput{}
@@ -56,11 +61,16 @@ type StartStreamEncryptionInput struct {
 	// Amazon Resource Name (ARN) to either an alias or a key, or an alias name
 	// prefixed by "alias/".You can also use a master key owned by Kinesis Data Streams
 	// by specifying the alias aws/kinesis .
+	//
 	//   - Key ARN example:
 	//   arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012
+	//
 	//   - Alias ARN example: arn:aws:kms:us-east-1:123456789012:alias/MyAliasName
+	//
 	//   - Globally unique key ID example: 12345678-1234-1234-1234-123456789012
+	//
 	//   - Alias name example: alias/MyAliasName
+	//
 	//   - Master key owned by Kinesis Data Streams: alias/aws/kinesis
 	//
 	// This member is required.

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_StopStreamEncryption.go

@@ -12,22 +12,28 @@ import (
 	smithyhttp "github.com/aws/smithy-go/transport/http"
 )
 
-// Disables server-side encryption for a specified stream. When invoking this API,
+// Disables server-side encryption for a specified stream.
-// 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
+// When invoking this API, you must use either the StreamARN or the StreamName
-// API. Stopping encryption is an asynchronous operation. Upon receiving the
+// parameter, or both. It is recommended that you use the StreamARN input
-// request, Kinesis Data Streams returns immediately and sets the status of the
+// parameter when you invoke this API.
-// stream to UPDATING . After the update is complete, Kinesis Data Streams sets the
+//
-// status of the stream back to ACTIVE . Stopping encryption normally takes a few
+// Stopping encryption is an asynchronous operation. Upon receiving the request,
-// seconds to complete, but it can take minutes. You can continue to read and write
+// Kinesis Data Streams returns immediately and sets the status of the stream to
-// data to your stream while its status is UPDATING . Once the status of the stream
+// UPDATING . After the update is complete, Kinesis Data Streams sets the status of
-// is ACTIVE , records written to the stream are no longer encrypted by Kinesis
+// the stream back to ACTIVE . Stopping encryption normally takes a few seconds to
-// Data Streams. API Limits: You can successfully disable server-side encryption 25
+// complete, but it can take minutes. You can continue to read and write data to
-// times in a rolling 24-hour period. Note: It can take up to 5 seconds after the
+// your stream while its status is UPDATING . Once the status of the stream is
-// stream is in an ACTIVE status before all records written to the stream are no
+// ACTIVE , records written to the stream are no longer encrypted by Kinesis Data
-// longer subject to encryption. After you disabled encryption, you can verify that
+// Streams.
-// encryption is not applied by inspecting the API response from PutRecord or
+//
-// PutRecords .
+// API Limits: You can successfully disable server-side encryption 25 times in a
+// rolling 24-hour period.
+//
+// Note: It can take up to 5 seconds after the stream is in an ACTIVE status
+// before all records written to the stream are no longer subject to encryption.
+// After you disabled encryption, you can verify that encryption is not applied by
+// inspecting the API response from PutRecord or PutRecords .
 func (c *Client) StopStreamEncryption(ctx context.Context, params *StopStreamEncryptionInput, optFns ...func(*Options)) (*StopStreamEncryptionOutput, error) {
 	if params == nil {
 		params = &StopStreamEncryptionInput{}
@@ -55,11 +61,16 @@ type StopStreamEncryptionInput struct {
 	// Amazon Resource Name (ARN) to either an alias or a key, or an alias name
 	// prefixed by "alias/".You can also use a master key owned by Kinesis Data Streams
 	// by specifying the alias aws/kinesis .
+	//
 	//   - Key ARN example:
 	//   arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012
+	//
 	//   - Alias ARN example: arn:aws:kms:us-east-1:123456789012:alias/MyAliasName
+	//
 	//   - Globally unique key ID example: 12345678-1234-1234-1234-123456789012
+	//
 	//   - Alias name example: alias/MyAliasName
+	//
 	//   - Master key owned by Kinesis Data Streams: alias/aws/kinesis
 	//
 	// This member is required.

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_SubscribeToShard.go

@@ -17,22 +17,27 @@ import (
 // specify in the ConsumerARN parameter and the shard you specify in the ShardId
 // parameter. After the connection is successfully established, Kinesis Data
 // Streams pushes records from the shard to the consumer over this connection.
-// Before you call this operation, call RegisterStreamConsumer to register the
+// Before you call this operation, call RegisterStreamConsumerto register the consumer with Kinesis Data
-// consumer with Kinesis Data Streams. When the SubscribeToShard call succeeds,
+// Streams.
-// your consumer starts receiving events of type SubscribeToShardEvent over the
+//
-// HTTP/2 connection for up to 5 minutes, after which time you need to call
+// When the SubscribeToShard call succeeds, your consumer starts receiving events
-// SubscribeToShard again to renew the subscription if you want to continue to
+// of type SubscribeToShardEventover the HTTP/2 connection for up to 5 minutes, after which time you
-// receive records. You can make one call to SubscribeToShard per second per
+// need to call SubscribeToShard again to renew the subscription if you want to
-// registered consumer per shard. For example, if you have a 4000 shard stream and
+// continue to receive records.
-// two registered stream consumers, you can make one SubscribeToShard request per
+//
-// second for each combination of shard and registered consumer, allowing you to
+// You can make one call to SubscribeToShard per second per registered consumer
-// subscribe both consumers to all 4000 shards in one second. If you call
+// per shard. For example, if you have a 4000 shard stream and two registered
-// SubscribeToShard again with the same ConsumerARN and ShardId within 5 seconds
+// stream consumers, you can make one SubscribeToShard request per second for each
-// of a successful call, you'll get a ResourceInUseException . If you call
+// combination of shard and registered consumer, allowing you to subscribe both
-// SubscribeToShard 5 seconds or more after a successful call, the second call
+// consumers to all 4000 shards in one second.
-// takes over the subscription and the previous connection expires or fails with a
+//
-// ResourceInUseException . For an example of how to use this operations, see
+// If you call SubscribeToShard again with the same ConsumerARN and ShardId within
-// Enhanced Fan-Out Using the Kinesis Data Streams API .
+// 5 seconds of a successful call, you'll get a ResourceInUseException . If you
+// call SubscribeToShard 5 seconds or more after a successful call, the second
+// call takes over the subscription and the previous connection expires or fails
+// with a ResourceInUseException .
+//
+// For an example of how to use this operations, see Enhanced Fan-Out Using the Kinesis Data Streams API.
 func (c *Client) SubscribeToShard(ctx context.Context, params *SubscribeToShardInput, optFns ...func(*Options)) (*SubscribeToShardOutput, error) {
 	if params == nil {
 		params = &SubscribeToShardInput{}
@@ -50,8 +55,7 @@ func (c *Client) SubscribeToShard(ctx context.Context, params *SubscribeToShardI
 
 type SubscribeToShardInput struct {
 
-	// For this parameter, use the value you obtained when you called
+	// For this parameter, use the value you obtained when you called RegisterStreamConsumer.
-	// RegisterStreamConsumer .
 	//
 	// This member is required.
 	ConsumerARN *string

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_UpdateShardCount.go

@@ -14,37 +14,53 @@ import (
 
 // Updates the shard count of the specified stream to the specified number of
 // shards. This API is only supported for the data streams with the provisioned
-// capacity mode. When invoking this API, you must use either the StreamARN or the
+// capacity mode.
-// StreamName parameter, or both. It is recommended that you use the StreamARN
+//
-// input parameter when you invoke this API. Updating the shard count is an
+// When invoking this API, you must use either the StreamARN or the StreamName
-// asynchronous operation. Upon receiving the request, Kinesis Data Streams returns
+// parameter, or both. It is recommended that you use the StreamARN input
-// immediately and sets the status of the stream to UPDATING . After the update is
+// parameter when you invoke this API.
-// 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
+// Updating the shard count is an asynchronous operation. Upon receiving the
-// to complete. You can continue to read and write data to your stream while its
+// request, Kinesis Data Streams returns immediately and sets the status of the
-// status is UPDATING . To update the shard count, Kinesis Data Streams performs
+// stream to UPDATING . After the update is complete, Kinesis Data Streams sets the
-// splits or merges on individual shards. This can cause short-lived shards to be
+// status of the stream back to ACTIVE . Depending on the size of the stream, the
-// created, in addition to the final shards. These short-lived shards count towards
+// scaling action could take a few minutes to complete. You can continue to read
-// your total shard limit for your account in the Region. When using this
+// and write data to your stream while its status is UPDATING .
-// operation, we recommend that you specify a target shard count that is a multiple
+//
-// of 25% (25%, 50%, 75%, 100%). You can specify any target value within your shard
+// To update the shard count, Kinesis Data Streams performs splits or merges on
-// limit. However, if you specify a target that isn't a multiple of 25%, the
+// individual shards. This can cause short-lived shards to be created, in addition
-// scaling action might take longer to complete. This operation has the following
+// to the final shards. These short-lived shards count towards your total shard
-// default limits. By default, you cannot do the following:
+// limit for your account in the Region.
+//
+// When using this operation, we recommend that you specify a target shard count
+// that is a multiple of 25% (25%, 50%, 75%, 100%). You can specify any target
+// value within your shard limit. However, if you specify a target that isn't a
+// multiple of 25%, the scaling action might take longer to complete.
+//
+// This operation has the following default limits. By default, you cannot do the
+// following:
+//
 //   - Scale more than ten times per rolling 24-hour period per stream
+//
 //   - Scale up to more than double your current shard count for a stream
+//
 //   - Scale down below half your current shard count for a stream
+//
 //   - Scale up to more than 10000 shards in a stream
+//
 //   - Scale a stream with more than 10000 shards down unless the result is less
 //     than 10000 shards
+//
 //   - Scale up to more than the shard limit for your account
+//
 //   - Make over 10 TPS. TPS over 10 will trigger the LimitExceededException
 //
-// For the default limits for an Amazon Web Services account, see Streams Limits (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
+// For the default limits for an Amazon Web Services account, see [Streams Limits] in the Amazon
-// in the Amazon Kinesis Data Streams Developer Guide. To request an increase in
+// Kinesis Data Streams Developer Guide. To request an increase in the call rate
-// the call rate limit, the shard limit for this API, or your overall shard limit,
+// limit, the shard limit for this API, or your overall shard limit, use the [limits form].
-// use the limits form (https://console.aws.amazon.com/support/v1#/case/create?issueType=service-limit-increase&limitType=service-code-kinesis)
+//
-// .
+// [limits form]: https://console.aws.amazon.com/support/v1#/case/create?issueType=service-limit-increase&limitType=service-code-kinesis
+// [Streams Limits]: https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html
 func (c *Client) UpdateShardCount(ctx context.Context, params *UpdateShardCountInput, optFns ...func(*Options)) (*UpdateShardCountOutput, error) {
 	if params == nil {
 		params = &UpdateShardCountInput{}
@@ -69,11 +85,15 @@ type UpdateShardCountInput struct {
 
 	// The new number of shards. This value has the following default limits. By
 	// default, you cannot do the following:
+	//
 	//   - Set this value to more than double your current shard count for a stream.
+	//
 	//   - Set this value below half your current shard count for a stream.
+	//
 	//   - Set this value to more than 10000 shards in a stream (the default limit for
 	//   shard count per stream is 10000 per account per region), unless you request a
 	//   limit increase.
+	//
 	//   - Scale a stream with more than 10000 shards down unless you set this value
 	//   to less than 10000 shards.
 	//

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/api_op_UpdateStreamMode.go

@@ -13,6 +13,7 @@ import (
 )
 
 //	Updates the capacity mode of the data stream. Currently, in Kinesis Data
+//
 // Streams, you can choose between an on-demand capacity mode and a provisioned
 // capacity mode for your data stream.
 func (c *Client) UpdateStreamMode(ctx context.Context, params *UpdateStreamModeInput, optFns ...func(*Options)) (*UpdateStreamModeOutput, error) {

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/deserializers.go

@@ -21,8 +21,17 @@ import (
 	"io"
 	"io/ioutil"
 	"strings"
+	"time"
 )
 
+func deserializeS3Expires(v string) (*time.Time, error) {
+	t, err := smithytime.ParseHTTPDate(v)
+	if err != nil {
+		return nil, nil
+	}
+	return &t, nil
+}
+
 type awsAwsjson11_deserializeOpAddTagsToStream struct {
 }
 

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/doc.go

@@ -3,7 +3,8 @@
 // Package kinesis provides the API client, operations, and parameter types for
 // Amazon Kinesis.
 //
-// Amazon Kinesis Data Streams Service API Reference Amazon Kinesis Data Streams
+// # Amazon Kinesis Data Streams Service API Reference
-// is a managed service that scales elastically for real-time processing of
+//
-// streaming big data.
+// Amazon Kinesis Data Streams is a managed service that scales elastically for
+// real-time processing of streaming big data.
 package kinesis

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/go_module_metadata.go

@@ -3,4 +3,4 @@
 package kinesis
 
 // goModuleVersion is the tagged release for this module
-const goModuleVersion = "1.27.4"
+const goModuleVersion = "1.27.8"

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/options.go

@@ -50,8 +50,10 @@ type Options struct {
 	// 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
+	// BaseEndpoint.
-	// endpoint, set the client option BaseEndpoint instead.
+	//
+	// 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
@@ -70,17 +72,20 @@ type Options struct {
 	// 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
+	// per operation call's retry max attempts.
-	// 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
+	// If specified in an operation call's functional options with a value that is
-	// RetryMaxAttempts value.
+	// 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
+	// Retryer option is not also specified.
-	// 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
+	// When creating a new API Clients this member will only be used if the Retryer
-	// overrides, may in the future.
+	// 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
@@ -97,8 +102,9 @@ type Options struct {
 
 	// The initial DefaultsMode used when the client options were constructed. If the
 	// DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved
-	// value was at that point in time. Currently does not support per operation call
+	// value was at that point in time.
-	// overrides, may in the future.
+	//
+	// Currently does not support per operation call overrides, may in the future.
 	resolvedDefaultsMode aws.DefaultsMode
 
 	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
@@ -143,6 +149,7 @@ func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
 // 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.
 func WithEndpointResolver(v EndpointResolver) func(*Options) {

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/types/enums.go

@@ -12,8 +12,9 @@ const (
 )
 
 // Values returns all known values for ConsumerStatus. Note that this can be
-// expanded in the future, and so it is only as up to date as the client. The
+// expanded in the future, and so it is only as up to date as the client.
-// ordering of this slice is not guaranteed to be stable across updates.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
 func (ConsumerStatus) Values() []ConsumerStatus {
 	return []ConsumerStatus{
 		"CREATING",
@@ -31,8 +32,9 @@ const (
 )
 
 // Values returns all known values for EncryptionType. Note that this can be
-// expanded in the future, and so it is only as up to date as the client. The
+// expanded in the future, and so it is only as up to date as the client.
-// ordering of this slice is not guaranteed to be stable across updates.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
 func (EncryptionType) Values() []EncryptionType {
 	return []EncryptionType{
 		"NONE",
@@ -55,8 +57,9 @@ const (
 )
 
 // Values returns all known values for MetricsName. Note that this can be expanded
-// in the future, and so it is only as up to date as the client. The ordering of
+// in the future, and so it is only as up to date as the client.
-// this slice is not guaranteed to be stable across updates.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
 func (MetricsName) Values() []MetricsName {
 	return []MetricsName{
 		"IncomingBytes",
@@ -78,8 +81,9 @@ const (
 )
 
 // Values returns all known values for ScalingType. Note that this can be expanded
-// in the future, and so it is only as up to date as the client. The ordering of
+// in the future, and so it is only as up to date as the client.
-// this slice is not guaranteed to be stable across updates.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
 func (ScalingType) Values() []ScalingType {
 	return []ScalingType{
 		"UNIFORM_SCALING",
@@ -99,8 +103,9 @@ const (
 )
 
 // Values returns all known values for ShardFilterType. Note that this can be
-// expanded in the future, and so it is only as up to date as the client. The
+// expanded in the future, and so it is only as up to date as the client.
-// ordering of this slice is not guaranteed to be stable across updates.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
 func (ShardFilterType) Values() []ShardFilterType {
 	return []ShardFilterType{
 		"AFTER_SHARD_ID",
@@ -124,8 +129,9 @@ const (
 )
 
 // Values returns all known values for ShardIteratorType. Note that this can be
-// expanded in the future, and so it is only as up to date as the client. The
+// expanded in the future, and so it is only as up to date as the client.
-// ordering of this slice is not guaranteed to be stable across updates.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
 func (ShardIteratorType) Values() []ShardIteratorType {
 	return []ShardIteratorType{
 		"AT_SEQUENCE_NUMBER",
@@ -145,8 +151,9 @@ const (
 )
 
 // Values returns all known values for StreamMode. Note that this can be expanded
-// in the future, and so it is only as up to date as the client. The ordering of
+// in the future, and so it is only as up to date as the client.
-// this slice is not guaranteed to be stable across updates.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
 func (StreamMode) Values() []StreamMode {
 	return []StreamMode{
 		"PROVISIONED",
@@ -165,8 +172,9 @@ const (
 )
 
 // Values returns all known values for StreamStatus. Note that this can be
-// expanded in the future, and so it is only as up to date as the client. The
+// expanded in the future, and so it is only as up to date as the client.
-// ordering of this slice is not guaranteed to be stable across updates.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
 func (StreamStatus) Values() []StreamStatus {
 	return []StreamStatus{
 		"CREATING",

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/types/errors.go

@@ -195,9 +195,10 @@ func (e *KMSDisabledException) ErrorCode() string {
 func (e *KMSDisabledException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
 
 // The request was rejected because the state of the specified resource isn't
-// valid for this request. For more information, see How Key State Affects Use of
+// valid for this request. For more information, see [How Key State Affects Use of a Customer Master Key]in the Amazon Web Services
-// a Customer Master Key (https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html)
+// Key Management Service Developer Guide.
-// in the Amazon Web Services Key Management Service Developer Guide.
+//
+// [How Key State Affects Use of a Customer Master Key]: https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html
 type KMSInvalidStateException struct {
 	Message *string
 
@@ -277,8 +278,10 @@ func (e *KMSOptInRequired) ErrorCode() string {
 func (e *KMSOptInRequired) ErrorFault() smithy.ErrorFault { return smithy.FaultClient }
 
 // The request was denied due to request throttling. For more information about
-// throttling, see Limits (https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#requests-per-second)
+// throttling, see [Limits]in the Amazon Web Services Key Management Service Developer
-// in the Amazon Web Services Key Management Service Developer Guide.
+// Guide.
+//
+// [Limits]: https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#requests-per-second
 type KMSThrottlingException struct {
 	Message *string
 
@@ -333,10 +336,11 @@ func (e *LimitExceededException) ErrorFault() smithy.ErrorFault { return smithy.
 
 // 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 (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
+// more information, see [Streams Limits]in the Amazon Kinesis Data Streams Developer Guide, and [Error Retries and Exponential Backoff in Amazon Web Services]
-// in the Amazon Kinesis Data Streams Developer Guide, and Error Retries and
-// Exponential Backoff in Amazon Web Services (https://docs.aws.amazon.com/general/latest/gr/api-retries.html)
 // in the Amazon Web Services General Reference.
+//
+// [Error Retries and Exponential Backoff in Amazon Web Services]: https://docs.aws.amazon.com/general/latest/gr/api-retries.html
+// [Streams Limits]: https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html
 type ProvisionedThroughputExceededException struct {
 	Message *string
 

vendor/github.com/aws/aws-sdk-go-v2/service/kinesis/types/types.go

@@ -35,10 +35,12 @@ type ChildShard struct {
 type Consumer struct {
 
 	// When you register a consumer, Kinesis Data Streams generates an ARN for it. You
-	// need this ARN to be able to call SubscribeToShard . If you delete a consumer and
+	// need this ARN to be able to call SubscribeToShard.
-	// then create a new one with the same name, it won't have the same ARN. That's
+	//
-	// because consumer ARNs contain the creation timestamp. This is important to keep
+	// If you delete a consumer and then create a new one with the same name, it won't
-	// in mind if you have IAM policies that reference consumer ARNs.
+	// have the same ARN. That's because consumer ARNs contain the creation timestamp.
+	// This is important to keep in mind if you have IAM policies that reference
+	// consumer ARNs.
 	//
 	// This member is required.
 	ConsumerARN *string
@@ -66,10 +68,12 @@ type Consumer struct {
 type ConsumerDescription struct {
 
 	// When you register a consumer, Kinesis Data Streams generates an ARN for it. You
-	// need this ARN to be able to call SubscribeToShard . If you delete a consumer and
+	// need this ARN to be able to call SubscribeToShard.
-	// then create a new one with the same name, it won't have the same ARN. That's
+	//
-	// because consumer ARNs contain the creation timestamp. This is important to keep
+	// If you delete a consumer and then create a new one with the same name, it won't
-	// in mind if you have IAM policies that reference consumer ARNs.
+	// have the same ARN. That's because consumer ARNs contain the creation timestamp.
+	// This is important to keep in mind if you have IAM policies that reference
+	// consumer ARNs.
 	//
 	// This member is required.
 	ConsumerARN *string
@@ -100,19 +104,30 @@ type ConsumerDescription struct {
 // Represents enhanced metrics types.
 type EnhancedMetrics struct {
 
-	// List of shard-level metrics. The following are the valid shard-level metrics.
+	// List of shard-level metrics.
-	// The value " ALL " enhances every metric.
+	//
+	// The following are the valid shard-level metrics. The value " ALL " enhances
+	// every metric.
+	//
 	//   - IncomingBytes
+	//
 	//   - IncomingRecords
+	//
 	//   - OutgoingBytes
+	//
 	//   - OutgoingRecords
+	//
 	//   - WriteProvisionedThroughputExceeded
+	//
 	//   - ReadProvisionedThroughputExceeded
+	//
 	//   - IteratorAgeMilliseconds
+	//
 	//   - ALL
-	// For more information, see Monitoring the Amazon Kinesis Data Streams Service
+	//
-	// with Amazon CloudWatch (https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html)
+	// For more information, see [Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch] in the Amazon Kinesis Data Streams Developer Guide.
-	// in the Amazon Kinesis Data Streams Developer Guide.
+	//
+	// [Monitoring the Amazon Kinesis Data Streams Service with Amazon CloudWatch]: https://docs.aws.amazon.com/kinesis/latest/dev/monitoring-with-cloudwatch.html
 	ShardLevelMetrics []MetricsName
 
 	noSmithyDocumentSerde
@@ -218,7 +233,9 @@ type Record struct {
 
 	// The encryption type used on the record. This parameter can be one of the
 	// following values:
+	//
 	//   - NONE : Do not encrypt the records in the stream.
+	//
 	//   - KMS : Use server-side encryption on the records in the stream using a
 	//   customer-managed Amazon Web Services KMS key.
 	EncryptionType EncryptionType
@@ -273,19 +290,26 @@ type Shard struct {
 type ShardFilter struct {
 
 	// The shard type specified in the ShardFilter parameter. This is a required
-	// property of the ShardFilter parameter. You can specify the following valid
+	// property of the ShardFilter parameter.
-	// values:
+	//
+	// You can specify the following valid values:
+	//
 	//   - AFTER_SHARD_ID - the response includes all the shards, starting with the
 	//   shard whose ID immediately follows the ShardId that you provided.
+	//
 	//   - AT_TRIM_HORIZON - the response includes all the shards that were open at
 	//   TRIM_HORIZON .
+	//
 	//   - FROM_TRIM_HORIZON - (default), the response includes all the shards within
 	//   the retention period of the data stream (trim to tip).
+	//
 	//   - AT_LATEST - the response includes only the currently open shards of the data
 	//   stream.
+	//
 	//   - AT_TIMESTAMP - the response includes all shards whose start timestamp is
 	//   less than or equal to the given timestamp and end timestamp is greater than or
 	//   equal to the given timestamp or still open.
+	//
 	//   - FROM_TIMESTAMP - the response incldues all closed shards whose end timestamp
 	//   is greater than or equal to the given timestamp and also all open shards.
 	//   Corrected to TRIM_HORIZON of the data stream if FROM_TIMESTAMP is less than
@@ -311,14 +335,21 @@ type ShardFilter struct {
 type StartingPosition struct {
 
 	// You can set the starting position to one of the following values:
+	//
 	// AT_SEQUENCE_NUMBER : Start streaming from the position denoted by the sequence
-	// number specified in the SequenceNumber field. AFTER_SEQUENCE_NUMBER : Start
+	// number specified in the SequenceNumber field.
-	// streaming right after the position denoted by the sequence number specified in
+	//
-	// the SequenceNumber field. AT_TIMESTAMP : Start streaming from the position
+	// AFTER_SEQUENCE_NUMBER : Start streaming right after the position denoted by the
-	// denoted by the time stamp specified in the Timestamp field. TRIM_HORIZON : Start
+	// sequence number specified in the SequenceNumber field.
-	// streaming at the last untrimmed record in the shard, which is the oldest data
+	//
-	// record in the shard. LATEST : Start streaming just after the most recent record
+	// AT_TIMESTAMP : Start streaming from the position denoted by the time stamp
-	// in the shard, so that you always read the most recent data in the shard.
+	// specified in the Timestamp field.
+	//
+	// TRIM_HORIZON : Start streaming at the last untrimmed record in the shard, which
+	// is the oldest data record in the shard.
+	//
+	// LATEST : Start streaming just after the most recent record in the shard, so that
+	// you always read the most recent data in the shard.
 	//
 	// This member is required.
 	Type ShardIteratorType
@@ -381,13 +412,17 @@ type StreamDescription struct {
 
 	// The current status of the stream being described. The stream status is one of
 	// the following states:
+	//
 	//   - CREATING - The stream is being created. Kinesis Data Streams immediately
 	//   returns and sets StreamStatus to CREATING .
+	//
 	//   - DELETING - The stream is being deleted. The specified stream is in the
 	//   DELETING state until Kinesis Data Streams completes the deletion.
+	//
 	//   - ACTIVE - The stream exists and is ready for read and write operations or
 	//   deletion. You should perform read and write operations only on an ACTIVE
 	//   stream.
+	//
 	//   - UPDATING - Shards in the stream are being merged or split. Read and write
 	//   operations continue to work while the stream is in the UPDATING state.
 	//
@@ -396,7 +431,9 @@ type StreamDescription struct {
 
 	// The server-side encryption type used on the stream. This parameter can be one
 	// of the following values:
+	//
 	//   - NONE : Do not encrypt the records in the stream.
+	//
 	//   - KMS : Use server-side encryption on the records in the stream using a
 	//   customer-managed Amazon Web Services KMS key.
 	EncryptionType EncryptionType
@@ -406,11 +443,16 @@ type StreamDescription struct {
 	// ARN to either an alias or a key, or an alias name prefixed by "alias/".You can
 	// also use a master key owned by Kinesis Data Streams by specifying the alias
 	// aws/kinesis .
+	//
 	//   - Key ARN example:
 	//   arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012
+	//
 	//   - Alias ARN example: arn:aws:kms:us-east-1:123456789012:alias/MyAliasName
+	//
 	//   - Globally unique key ID example: 12345678-1234-1234-1234-123456789012
+	//
 	//   - Alias name example: alias/MyAliasName
+	//
 	//   - Master key owned by Kinesis Data Streams: alias/aws/kinesis
 	KeyId *string
 
@@ -457,13 +499,17 @@ type StreamDescriptionSummary struct {
 
 	// The current status of the stream being described. The stream status is one of
 	// the following states:
+	//
 	//   - CREATING - The stream is being created. Kinesis Data Streams immediately
 	//   returns and sets StreamStatus to CREATING .
+	//
 	//   - DELETING - The stream is being deleted. The specified stream is in the
 	//   DELETING state until Kinesis Data Streams completes the deletion.
+	//
 	//   - ACTIVE - The stream exists and is ready for read and write operations or
 	//   deletion. You should perform read and write operations only on an ACTIVE
 	//   stream.
+	//
 	//   - UPDATING - Shards in the stream are being merged or split. Read and write
 	//   operations continue to work while the stream is in the UPDATING state.
 	//
@@ -474,7 +520,9 @@ type StreamDescriptionSummary struct {
 	ConsumerCount *int32
 
 	// The encryption type used. This value is one of the following:
+	//
 	//   - KMS
+	//
 	//   - NONE
 	EncryptionType EncryptionType
 
@@ -483,11 +531,16 @@ type StreamDescriptionSummary struct {
 	// ARN to either an alias or a key, or an alias name prefixed by "alias/".You can
 	// also use a master key owned by Kinesis Data Streams by specifying the alias
 	// aws/kinesis .
+	//
 	//   - Key ARN example:
 	//   arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012
+	//
 	//   - Alias ARN example: arn:aws:kms:us-east-1:123456789012:alias/MyAliasName
+	//
 	//   - Globally unique key ID example: 12345678-1234-1234-1234-123456789012
+	//
 	//   - Alias name example: alias/MyAliasName
+	//
 	//   - Master key owned by Kinesis Data Streams: alias/aws/kinesis
 	KeyId *string
 
@@ -500,6 +553,7 @@ type StreamDescriptionSummary struct {
 }
 
 //	Specifies the capacity mode to which you want to set your data stream.
+//
 // Currently, in Kinesis Data Streams, you can choose between an on-demand capacity
 // mode and a provisioned capacity mode for your data streams.
 type StreamModeDetails struct {
@@ -543,14 +597,14 @@ type StreamSummary struct {
 	noSmithyDocumentSerde
 }
 
-// After you call SubscribeToShard , Kinesis Data Streams sends events of this type
+// After you call SubscribeToShard, Kinesis Data Streams sends events of this type over an HTTP/2
-// over an HTTP/2 connection to your consumer.
+// connection to your consumer.
 type SubscribeToShardEvent struct {
 
-	// Use this as SequenceNumber in the next call to SubscribeToShard , with
+	// Use this as SequenceNumber in the next call to SubscribeToShard, with StartingPosition set to
-	// StartingPosition set to AT_SEQUENCE_NUMBER or AFTER_SEQUENCE_NUMBER . Use
+	// AT_SEQUENCE_NUMBER or AFTER_SEQUENCE_NUMBER . Use ContinuationSequenceNumber
-	// ContinuationSequenceNumber for checkpointing because it captures your shard
+	// for checkpointing because it captures your shard progress even when no data is
-	// progress even when no data is written to the shard.
+	// written to the shard.
 	//
 	// This member is required.
 	ContinuationSequenceNumber *string
@@ -585,9 +639,8 @@ type SubscribeToShardEventStream interface {
 	isSubscribeToShardEventStream()
 }
 
-// After you call SubscribeToShard , Kinesis Data Streams sends events of this type
+// After you call SubscribeToShard, Kinesis Data Streams sends events of this type to your
-// to your consumer. For an example of how to handle these events, see Enhanced
+// consumer. For an example of how to handle these events, see Enhanced Fan-Out Using the Kinesis Data Streams API.
-// Fan-Out Using the Kinesis Data Streams API .
 type SubscribeToShardEventStreamMemberSubscribeToShardEvent struct {
 	Value SubscribeToShardEvent
 

vendor/modules.txt

@@ -92,7 +92,7 @@ github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery
 # github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.9
 ## explicit; go 1.20
 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url
-# github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.4
+# github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.8
 ## explicit; go 1.20
 github.com/aws/aws-sdk-go-v2/service/kinesis
 github.com/aws/aws-sdk-go-v2/service/kinesis/internal/customizations