Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ChildShard

type ChildShard struct {

	// The range of possible hash key values for the shard, which is a set of ordered
	// contiguous positive integers.
	//
	// This member is required.
	HashKeyRange *HashKeyRange

	// This member is required.
	ParentShards []string

	// This member is required.
	ShardId *string
}

type Consumer

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
	// 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
	// in mind if you have IAM policies that reference consumer ARNs.
	//
	// This member is required.
	ConsumerARN *string

	//
	//
	// This member is required.
	ConsumerCreationTimestamp *time.Time

	// The name of the consumer is something you choose when you register the consumer.
	//
	// This member is required.
	ConsumerName *string

	// A consumer can't read data while in the CREATING or DELETING states.
	//
	// This member is required.
	ConsumerStatus ConsumerStatus
}

    An object that represents the details of the consumer you registered. This type of object is returned by RegisterStreamConsumer.

    type ConsumerDescription

    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
    	// 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
    	// in mind if you have IAM policies that reference consumer ARNs.
    	//
    	// This member is required.
    	ConsumerARN *string
    
    	//
    	//
    	// This member is required.
    	ConsumerCreationTimestamp *time.Time
    
    	// The name of the consumer is something you choose when you register the consumer.
    	//
    	// This member is required.
    	ConsumerName *string
    
    	// A consumer can't read data while in the CREATING or DELETING states.
    	//
    	// This member is required.
    	ConsumerStatus ConsumerStatus
    
    	// The ARN of the stream with which you registered the consumer.
    	//
    	// This member is required.
    	StreamARN *string
    }

      An object that represents the details of a registered consumer. This type of object is returned by DescribeStreamConsumer.

      type ConsumerStatus

      type ConsumerStatus string
      const (
      	ConsumerStatusCreating ConsumerStatus = "CREATING"
      	ConsumerStatusDeleting ConsumerStatus = "DELETING"
      	ConsumerStatusActive   ConsumerStatus = "ACTIVE"
      )

        Enum values for ConsumerStatus

        func (ConsumerStatus) Values

        func (ConsumerStatus) Values() []ConsumerStatus

          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 ordering of this slice is not guaranteed to be stable across updates.

          type EncryptionType

          type EncryptionType string
          const (
          	EncryptionTypeNone EncryptionType = "NONE"
          	EncryptionTypeKms  EncryptionType = "KMS"
          )

            Enum values for EncryptionType

            func (EncryptionType) Values

            func (EncryptionType) Values() []EncryptionType

              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 ordering of this slice is not guaranteed to be stable across updates.

              type EnhancedMetrics

              type EnhancedMetrics struct {
              
              	// List of shard-level metrics. 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)
              	// in the Amazon Kinesis Data Streams Developer Guide.
              	ShardLevelMetrics []MetricsName
              }

                Represents enhanced metrics types.

                type ExpiredIteratorException

                type ExpiredIteratorException struct {
                	Message *string
                }

                  The provided iterator exceeds the maximum age allowed.

                  func (*ExpiredIteratorException) Error

                  func (e *ExpiredIteratorException) Error() string

                  func (*ExpiredIteratorException) ErrorCode

                  func (e *ExpiredIteratorException) ErrorCode() string

                  func (*ExpiredIteratorException) ErrorFault

                  func (e *ExpiredIteratorException) ErrorFault() smithy.ErrorFault

                  func (*ExpiredIteratorException) ErrorMessage

                  func (e *ExpiredIteratorException) ErrorMessage() string

                  type ExpiredNextTokenException

                  type ExpiredNextTokenException struct {
                  	Message *string
                  }

                    The pagination token passed to the operation is expired.

                    func (*ExpiredNextTokenException) Error

                    func (e *ExpiredNextTokenException) Error() string

                    func (*ExpiredNextTokenException) ErrorCode

                    func (e *ExpiredNextTokenException) ErrorCode() string

                    func (*ExpiredNextTokenException) ErrorFault

                    func (*ExpiredNextTokenException) ErrorMessage

                    func (e *ExpiredNextTokenException) ErrorMessage() string

                    type HashKeyRange

                    type HashKeyRange struct {
                    
                    	// The ending hash key of the hash key range.
                    	//
                    	// This member is required.
                    	EndingHashKey *string
                    
                    	// The starting hash key of the hash key range.
                    	//
                    	// This member is required.
                    	StartingHashKey *string
                    }

                      The range of possible hash key values for the shard, which is a set of ordered contiguous positive integers.

                      type InvalidArgumentException

                      type InvalidArgumentException struct {
                      	Message *string
                      }

                        A specified parameter exceeds its restrictions, is not supported, or can't be used. For more information, see the returned message.

                        func (*InvalidArgumentException) Error

                        func (e *InvalidArgumentException) Error() string

                        func (*InvalidArgumentException) ErrorCode

                        func (e *InvalidArgumentException) ErrorCode() string

                        func (*InvalidArgumentException) ErrorFault

                        func (e *InvalidArgumentException) ErrorFault() smithy.ErrorFault

                        func (*InvalidArgumentException) ErrorMessage

                        func (e *InvalidArgumentException) ErrorMessage() string

                        type KMSAccessDeniedException

                        type KMSAccessDeniedException struct {
                        	Message *string
                        }

                          The ciphertext references a key that doesn't exist or that you don't have access to.

                          func (*KMSAccessDeniedException) Error

                          func (e *KMSAccessDeniedException) Error() string

                          func (*KMSAccessDeniedException) ErrorCode

                          func (e *KMSAccessDeniedException) ErrorCode() string

                          func (*KMSAccessDeniedException) ErrorFault

                          func (e *KMSAccessDeniedException) ErrorFault() smithy.ErrorFault

                          func (*KMSAccessDeniedException) ErrorMessage

                          func (e *KMSAccessDeniedException) ErrorMessage() string

                          type KMSDisabledException

                          type KMSDisabledException struct {
                          	Message *string
                          }

                            The request was rejected because the specified customer master key (CMK) isn't enabled.

                            func (*KMSDisabledException) Error

                            func (e *KMSDisabledException) Error() string

                            func (*KMSDisabledException) ErrorCode

                            func (e *KMSDisabledException) ErrorCode() string

                            func (*KMSDisabledException) ErrorFault

                            func (e *KMSDisabledException) ErrorFault() smithy.ErrorFault

                            func (*KMSDisabledException) ErrorMessage

                            func (e *KMSDisabledException) ErrorMessage() string

                            type KMSInvalidStateException

                            type KMSInvalidStateException struct {
                            	Message *string
                            }

                              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 a Customer Master Key (https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html) in the AWS Key Management Service Developer Guide.

                              func (*KMSInvalidStateException) Error

                              func (e *KMSInvalidStateException) Error() string

                              func (*KMSInvalidStateException) ErrorCode

                              func (e *KMSInvalidStateException) ErrorCode() string

                              func (*KMSInvalidStateException) ErrorFault

                              func (e *KMSInvalidStateException) ErrorFault() smithy.ErrorFault

                              func (*KMSInvalidStateException) ErrorMessage

                              func (e *KMSInvalidStateException) ErrorMessage() string

                              type KMSNotFoundException

                              type KMSNotFoundException struct {
                              	Message *string
                              }

                                The request was rejected because the specified entity or resource can't be found.

                                func (*KMSNotFoundException) Error

                                func (e *KMSNotFoundException) Error() string

                                func (*KMSNotFoundException) ErrorCode

                                func (e *KMSNotFoundException) ErrorCode() string

                                func (*KMSNotFoundException) ErrorFault

                                func (e *KMSNotFoundException) ErrorFault() smithy.ErrorFault

                                func (*KMSNotFoundException) ErrorMessage

                                func (e *KMSNotFoundException) ErrorMessage() string

                                type KMSOptInRequired

                                type KMSOptInRequired struct {
                                	Message *string
                                }

                                  The AWS access key ID needs a subscription for the service.

                                  func (*KMSOptInRequired) Error

                                  func (e *KMSOptInRequired) Error() string

                                  func (*KMSOptInRequired) ErrorCode

                                  func (e *KMSOptInRequired) ErrorCode() string

                                  func (*KMSOptInRequired) ErrorFault

                                  func (e *KMSOptInRequired) ErrorFault() smithy.ErrorFault

                                  func (*KMSOptInRequired) ErrorMessage

                                  func (e *KMSOptInRequired) ErrorMessage() string

                                  type KMSThrottlingException

                                  type KMSThrottlingException struct {
                                  	Message *string
                                  }

                                    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) in the AWS Key Management Service Developer Guide.

                                    func (*KMSThrottlingException) Error

                                    func (e *KMSThrottlingException) Error() string

                                    func (*KMSThrottlingException) ErrorCode

                                    func (e *KMSThrottlingException) ErrorCode() string

                                    func (*KMSThrottlingException) ErrorFault

                                    func (e *KMSThrottlingException) ErrorFault() smithy.ErrorFault

                                    func (*KMSThrottlingException) ErrorMessage

                                    func (e *KMSThrottlingException) ErrorMessage() string

                                    type LimitExceededException

                                    type LimitExceededException struct {
                                    	Message *string
                                    }

                                      The requested resource exceeds the maximum number allowed, or the number of concurrent stream requests exceeds the maximum number allowed.

                                      func (*LimitExceededException) Error

                                      func (e *LimitExceededException) Error() string

                                      func (*LimitExceededException) ErrorCode

                                      func (e *LimitExceededException) ErrorCode() string

                                      func (*LimitExceededException) ErrorFault

                                      func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                      func (*LimitExceededException) ErrorMessage

                                      func (e *LimitExceededException) ErrorMessage() string

                                      type MetricsName

                                      type MetricsName string
                                      const (
                                      	MetricsNameIncomingBytes                      MetricsName = "IncomingBytes"
                                      	MetricsNameIncomingRecords                    MetricsName = "IncomingRecords"
                                      	MetricsNameOutgoingBytes                      MetricsName = "OutgoingBytes"
                                      	MetricsNameOutgoingRecords                    MetricsName = "OutgoingRecords"
                                      	MetricsNameWriteProvisionedThroughputExceeded MetricsName = "WriteProvisionedThroughputExceeded"
                                      	MetricsNameReadProvisionedThroughputExceeded  MetricsName = "ReadProvisionedThroughputExceeded"
                                      	MetricsNameIteratorAgeMilliseconds            MetricsName = "IteratorAgeMilliseconds"
                                      	MetricsNameAll                                MetricsName = "ALL"
                                      )

                                        Enum values for MetricsName

                                        func (MetricsName) Values

                                        func (MetricsName) Values() []MetricsName

                                          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 this slice is not guaranteed to be stable across updates.

                                          type ProvisionedThroughputExceededException

                                          type ProvisionedThroughputExceededException struct {
                                          	Message *string
                                          }

                                            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) in the Amazon Kinesis Data Streams Developer Guide, and Error Retries and Exponential Backoff in AWS (https://docs.aws.amazon.com/general/latest/gr/api-retries.html) in the AWS General Reference.

                                            func (*ProvisionedThroughputExceededException) Error

                                            func (*ProvisionedThroughputExceededException) ErrorCode

                                            func (*ProvisionedThroughputExceededException) ErrorFault

                                            func (*ProvisionedThroughputExceededException) ErrorMessage

                                            type PutRecordsRequestEntry

                                            type PutRecordsRequestEntry struct {
                                            
                                            	// The data blob to put into the record, which is base64-encoded when the blob is
                                            	// serialized. When the data blob (the payload before base64-encoding) is added to
                                            	// the partition key size, the total size must not exceed the maximum record size
                                            	// (1 MiB).
                                            	//
                                            	// This member is required.
                                            	Data []byte
                                            
                                            	// Determines which shard in the stream the data record is assigned to. Partition
                                            	// keys are Unicode strings with a maximum length limit of 256 characters for each
                                            	// key. Amazon Kinesis Data Streams uses the partition key as input to a hash
                                            	// function that maps the partition key and associated data to a specific shard.
                                            	// Specifically, 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.
                                            	//
                                            	// This member is required.
                                            	PartitionKey *string
                                            
                                            	// The hash value used to determine explicitly the shard that the data record is
                                            	// assigned to by overriding the partition key hash.
                                            	ExplicitHashKey *string
                                            }

                                              Represents the output for PutRecords.

                                              type PutRecordsResultEntry

                                              type PutRecordsResultEntry struct {
                                              
                                              	// The error code for an individual record result. ErrorCodes can be either
                                              	// ProvisionedThroughputExceededException or InternalFailure.
                                              	ErrorCode *string
                                              
                                              	// The error message for an individual record result. An ErrorCode value of
                                              	// ProvisionedThroughputExceededException has an error message that includes the
                                              	// account ID, stream name, and shard ID. An ErrorCode value of InternalFailure has
                                              	// the error message "Internal Service Failure".
                                              	ErrorMessage *string
                                              
                                              	// The sequence number for an individual record result.
                                              	SequenceNumber *string
                                              
                                              	// The shard ID for an individual record result.
                                              	ShardId *string
                                              }

                                                Represents the result of an individual record from a PutRecords request. A record that is successfully added to a stream includes SequenceNumber and ShardId in the result. A record that fails to be added to the stream includes ErrorCode and ErrorMessage in the result.

                                                type Record

                                                type Record struct {
                                                
                                                	// The data blob. The data in the blob is both opaque and immutable to Kinesis Data
                                                	// Streams, which does not inspect, interpret, or change the data in the blob in
                                                	// any way. When the data blob (the payload before base64-encoding) is added to the
                                                	// partition key size, the total size must not exceed the maximum record size (1
                                                	// MiB).
                                                	//
                                                	// This member is required.
                                                	Data []byte
                                                
                                                	// Identifies which shard in the stream the data record is assigned to.
                                                	//
                                                	// This member is required.
                                                	PartitionKey *string
                                                
                                                	// The unique identifier of the record within its shard.
                                                	//
                                                	// This member is required.
                                                	SequenceNumber *string
                                                
                                                	// The approximate time that the record was inserted into the stream.
                                                	ApproximateArrivalTimestamp *time.Time
                                                
                                                	// 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 AWS
                                                	// KMS key.
                                                	EncryptionType EncryptionType
                                                }

                                                  The unit of data of the Kinesis data stream, which is composed of a sequence number, a partition key, and a data blob.

                                                  type ResourceInUseException

                                                  type ResourceInUseException struct {
                                                  	Message *string
                                                  }

                                                    The resource is not available for this operation. For successful operation, the resource must be in the ACTIVE state.

                                                    func (*ResourceInUseException) Error

                                                    func (e *ResourceInUseException) Error() string

                                                    func (*ResourceInUseException) ErrorCode

                                                    func (e *ResourceInUseException) ErrorCode() string

                                                    func (*ResourceInUseException) ErrorFault

                                                    func (e *ResourceInUseException) ErrorFault() smithy.ErrorFault

                                                    func (*ResourceInUseException) ErrorMessage

                                                    func (e *ResourceInUseException) ErrorMessage() string

                                                    type ResourceNotFoundException

                                                    type ResourceNotFoundException struct {
                                                    	Message *string
                                                    }

                                                      The requested resource could not be found. The stream might not be specified correctly.

                                                      func (*ResourceNotFoundException) Error

                                                      func (e *ResourceNotFoundException) Error() string

                                                      func (*ResourceNotFoundException) ErrorCode

                                                      func (e *ResourceNotFoundException) ErrorCode() string

                                                      func (*ResourceNotFoundException) ErrorFault

                                                      func (*ResourceNotFoundException) ErrorMessage

                                                      func (e *ResourceNotFoundException) ErrorMessage() string

                                                      type ScalingType

                                                      type ScalingType string
                                                      const (
                                                      	ScalingTypeUniformScaling ScalingType = "UNIFORM_SCALING"
                                                      )

                                                        Enum values for ScalingType

                                                        func (ScalingType) Values

                                                        func (ScalingType) Values() []ScalingType

                                                          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 this slice is not guaranteed to be stable across updates.

                                                          type SequenceNumberRange

                                                          type SequenceNumberRange struct {
                                                          
                                                          	// The starting sequence number for the range.
                                                          	//
                                                          	// This member is required.
                                                          	StartingSequenceNumber *string
                                                          
                                                          	// The ending sequence number for the range. Shards that are in the OPEN state have
                                                          	// an ending sequence number of null.
                                                          	EndingSequenceNumber *string
                                                          }

                                                            The range of possible sequence numbers for the shard.

                                                            type Shard

                                                            type Shard struct {
                                                            
                                                            	// The range of possible hash key values for the shard, which is a set of ordered
                                                            	// contiguous positive integers.
                                                            	//
                                                            	// This member is required.
                                                            	HashKeyRange *HashKeyRange
                                                            
                                                            	// The range of possible sequence numbers for the shard.
                                                            	//
                                                            	// This member is required.
                                                            	SequenceNumberRange *SequenceNumberRange
                                                            
                                                            	// The unique identifier of the shard within the stream.
                                                            	//
                                                            	// This member is required.
                                                            	ShardId *string
                                                            
                                                            	// The shard ID of the shard adjacent to the shard's parent.
                                                            	AdjacentParentShardId *string
                                                            
                                                            	// The shard ID of the shard's parent.
                                                            	ParentShardId *string
                                                            }

                                                              A uniquely identified group of data records in a Kinesis data stream.

                                                              type ShardFilter

                                                              type ShardFilter struct {
                                                              
                                                              	// This member is required.
                                                              	Type ShardFilterType
                                                              
                                                              	ShardId *string
                                                              
                                                              	Timestamp *time.Time
                                                              }

                                                              type ShardFilterType

                                                              type ShardFilterType string
                                                              const (
                                                              	ShardFilterTypeAfterShardId    ShardFilterType = "AFTER_SHARD_ID"
                                                              	ShardFilterTypeAtTrimHorizon   ShardFilterType = "AT_TRIM_HORIZON"
                                                              	ShardFilterTypeFromTrimHorizon ShardFilterType = "FROM_TRIM_HORIZON"
                                                              	ShardFilterTypeAtLatest        ShardFilterType = "AT_LATEST"
                                                              	ShardFilterTypeAtTimestamp     ShardFilterType = "AT_TIMESTAMP"
                                                              	ShardFilterTypeFromTimestamp   ShardFilterType = "FROM_TIMESTAMP"
                                                              )

                                                                Enum values for ShardFilterType

                                                                func (ShardFilterType) Values

                                                                func (ShardFilterType) Values() []ShardFilterType

                                                                  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 ordering of this slice is not guaranteed to be stable across updates.

                                                                  type ShardIteratorType

                                                                  type ShardIteratorType string
                                                                  const (
                                                                  	ShardIteratorTypeAtSequenceNumber    ShardIteratorType = "AT_SEQUENCE_NUMBER"
                                                                  	ShardIteratorTypeAfterSequenceNumber ShardIteratorType = "AFTER_SEQUENCE_NUMBER"
                                                                  	ShardIteratorTypeTrimHorizon         ShardIteratorType = "TRIM_HORIZON"
                                                                  	ShardIteratorTypeLatest              ShardIteratorType = "LATEST"
                                                                  	ShardIteratorTypeAtTimestamp         ShardIteratorType = "AT_TIMESTAMP"
                                                                  )

                                                                    Enum values for ShardIteratorType

                                                                    func (ShardIteratorType) Values

                                                                      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 ordering of this slice is not guaranteed to be stable across updates.

                                                                      type StreamDescription

                                                                      type StreamDescription struct {
                                                                      
                                                                      	// Represents the current enhanced monitoring settings of the stream.
                                                                      	//
                                                                      	// This member is required.
                                                                      	EnhancedMonitoring []EnhancedMetrics
                                                                      
                                                                      	// If set to true, more shards in the stream are available to describe.
                                                                      	//
                                                                      	// This member is required.
                                                                      	HasMoreShards *bool
                                                                      
                                                                      	// The current retention period, in hours. Minimum value of 24. Maximum value of
                                                                      	// 168.
                                                                      	//
                                                                      	// This member is required.
                                                                      	RetentionPeriodHours *int32
                                                                      
                                                                      	// The shards that comprise the stream.
                                                                      	//
                                                                      	// This member is required.
                                                                      	Shards []Shard
                                                                      
                                                                      	// The Amazon Resource Name (ARN) for the stream being described.
                                                                      	//
                                                                      	// This member is required.
                                                                      	StreamARN *string
                                                                      
                                                                      	// The approximate time that the stream was created.
                                                                      	//
                                                                      	// This member is required.
                                                                      	StreamCreationTimestamp *time.Time
                                                                      
                                                                      	// The name of the stream being described.
                                                                      	//
                                                                      	// This member is required.
                                                                      	StreamName *string
                                                                      
                                                                      	// 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.
                                                                      	//
                                                                      	// This member is required.
                                                                      	StreamStatus StreamStatus
                                                                      
                                                                      	// 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
                                                                      	// AWS KMS key.
                                                                      	EncryptionType EncryptionType
                                                                      
                                                                      	// The GUID for the customer-managed AWS KMS key to use for encryption. This value
                                                                      	// can be a globally unique identifier, a fully specified 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
                                                                      }

                                                                        Represents the output for DescribeStream.

                                                                        type StreamDescriptionSummary

                                                                        type StreamDescriptionSummary struct {
                                                                        
                                                                        	// Represents the current enhanced monitoring settings of the stream.
                                                                        	//
                                                                        	// This member is required.
                                                                        	EnhancedMonitoring []EnhancedMetrics
                                                                        
                                                                        	// The number of open shards in the stream.
                                                                        	//
                                                                        	// This member is required.
                                                                        	OpenShardCount *int32
                                                                        
                                                                        	// The current retention period, in hours.
                                                                        	//
                                                                        	// This member is required.
                                                                        	RetentionPeriodHours *int32
                                                                        
                                                                        	// The Amazon Resource Name (ARN) for the stream being described.
                                                                        	//
                                                                        	// This member is required.
                                                                        	StreamARN *string
                                                                        
                                                                        	// The approximate time that the stream was created.
                                                                        	//
                                                                        	// This member is required.
                                                                        	StreamCreationTimestamp *time.Time
                                                                        
                                                                        	// The name of the stream being described.
                                                                        	//
                                                                        	// This member is required.
                                                                        	StreamName *string
                                                                        
                                                                        	// 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.
                                                                        	//
                                                                        	// This member is required.
                                                                        	StreamStatus StreamStatus
                                                                        
                                                                        	// The number of enhanced fan-out consumers registered with the stream.
                                                                        	ConsumerCount *int32
                                                                        
                                                                        	// The encryption type used. This value is one of the following:
                                                                        	//
                                                                        	// * KMS
                                                                        	//
                                                                        	// * NONE
                                                                        	EncryptionType EncryptionType
                                                                        
                                                                        	// The GUID for the customer-managed AWS KMS key to use for encryption. This value
                                                                        	// can be a globally unique identifier, a fully specified 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
                                                                        }

                                                                          Represents the output for DescribeStreamSummary

                                                                          type StreamStatus

                                                                          type StreamStatus string
                                                                          const (
                                                                          	StreamStatusCreating StreamStatus = "CREATING"
                                                                          	StreamStatusDeleting StreamStatus = "DELETING"
                                                                          	StreamStatusActive   StreamStatus = "ACTIVE"
                                                                          	StreamStatusUpdating StreamStatus = "UPDATING"
                                                                          )

                                                                            Enum values for StreamStatus

                                                                            func (StreamStatus) Values

                                                                            func (StreamStatus) Values() []StreamStatus

                                                                              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 ordering of this slice is not guaranteed to be stable across updates.

                                                                              type Tag

                                                                              type Tag struct {
                                                                              
                                                                              	// A unique identifier for the tag. Maximum length: 128 characters. Valid
                                                                              	// characters: Unicode letters, digits, white space, _ . / = + - % @
                                                                              	//
                                                                              	// This member is required.
                                                                              	Key *string
                                                                              
                                                                              	// An optional string, typically used to describe or define the tag. Maximum
                                                                              	// length: 256 characters. Valid characters: Unicode letters, digits, white space,
                                                                              	// _ . / = + - % @
                                                                              	Value *string
                                                                              }

                                                                                Metadata assigned to the stream, consisting of a key-value pair.