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.
	ConsumerARN *string
	// A consumer can't read data while in the CREATING or DELETING states.
	ConsumerStatus ConsumerStatus
	// The name of the consumer is something you choose when you register the consumer.
	ConsumerName *string
	//
	ConsumerCreationTimestamp *time.Time
}

type ConsumerDescription struct {
	//
	ConsumerCreationTimestamp *time.Time
	// The ARN of the stream with which you registered the consumer.
	StreamARN *string
	// A consumer can't read data while in the CREATING or DELETING states.
	ConsumerStatus ConsumerStatus
	// 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.
	ConsumerARN *string
	// The name of the consumer is something you choose when you register the consumer.
	ConsumerName *string
}

type ConsumerStatus string

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

type EncryptionType string

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

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
}

type ExpiredIteratorException struct {
	Message *string
}

type ExpiredNextTokenException struct {
	Message *string
}

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

type InternalFailureException struct {
	Message *string
}

type InvalidArgumentException struct {
	Message *string
}

type KMSAccessDeniedException struct {
	Message *string
}

type KMSDisabledException struct {
	Message *string
}

type KMSInvalidStateException struct {
	Message *string
}

type KMSNotFoundException struct {
	Message *string
}

type KMSOptInRequired struct {
	Message *string
}

type KMSThrottlingException struct {
	Message *string
}

type LimitExceededException struct {
	Message *string
}

type MetricsName string

const (
	MetricsNameIncoming_bytes                        MetricsName = "IncomingBytes"
	MetricsNameIncoming_records                      MetricsName = "IncomingRecords"
	MetricsNameOutgoing_bytes                        MetricsName = "OutgoingBytes"
	MetricsNameOutgoing_records                      MetricsName = "OutgoingRecords"
	MetricsNameWrite_provisioned_throughput_exceeded MetricsName = "WriteProvisionedThroughputExceeded"
	MetricsNameRead_provisioned_throughput_exceeded  MetricsName = "ReadProvisionedThroughputExceeded"
	MetricsNameIterator_age_milliseconds             MetricsName = "IteratorAgeMilliseconds"
	MetricsNameAll                                   MetricsName = "ALL"
)

type ProvisionedThroughputExceededException struct {
	Message *string
}

type PutRecordsRequestEntry struct {
	// 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.
	PartitionKey *string
	// 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 MB).
	Data []byte
	// The hash value used to determine explicitly the shard that the data record is
	// assigned to by overriding the partition key hash.
	ExplicitHashKey *string
}

type PutRecordsResultEntry struct {
	// The shard ID for an individual record result.
	ShardId *string
	// The sequence number for an individual record result.
	SequenceNumber *string
	// 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
}

type Record struct {
	// Identifies which shard in the stream the data record is assigned to.
	PartitionKey *string
	// 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
	// MB).
	Data []byte
	// The unique identifier of the record within its shard.
	SequenceNumber *string
	// 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 approximate time that the record was inserted into the stream.
	ApproximateArrivalTimestamp *time.Time
}

type ResourceInUseException struct {
	Message *string
}

type ResourceNotFoundException struct {
	Message *string
}

type ScalingType string

const (
	ScalingTypeUniform_scaling ScalingType = "UNIFORM_SCALING"
)

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

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

type ShardIteratorType string

const (
	ShardIteratorTypeAt_sequence_number    ShardIteratorType = "AT_SEQUENCE_NUMBER"
	ShardIteratorTypeAfter_sequence_number ShardIteratorType = "AFTER_SEQUENCE_NUMBER"
	ShardIteratorTypeTrim_horizon          ShardIteratorType = "TRIM_HORIZON"
	ShardIteratorTypeLatest                ShardIteratorType = "LATEST"
	ShardIteratorTypeAt_timestamp          ShardIteratorType = "AT_TIMESTAMP"
)

type StartingPosition struct {
	SequenceNumber *string
	Type           ShardIteratorType
	Timestamp      *time.Time
}

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 AWS KMS key.
	EncryptionType EncryptionType
	// The name of the stream being described.
	StreamName *string
	// The approximate time that the stream was created.
	StreamCreationTimestamp *time.Time
	// If set to true, more shards in the stream are available to describe.
	HasMoreShards *bool
	// 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
	// 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.
	StreamStatus StreamStatus
	// The shards that comprise the stream.
	Shards []*Shard
	// The Amazon Resource Name (ARN) for the stream being described.
	StreamARN *string
	// The current retention period, in hours.
	RetentionPeriodHours *int32
	// Represents the current enhanced monitoring settings of the stream.
	EnhancedMonitoring []*EnhancedMetrics
}

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

type StreamStatus string

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

type SubscribeToShardEvent struct {
	// The number of milliseconds the read records are from the tip of the stream,
	// 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
	//
	Records []*Record
	// Use this as StartingSequenceNumber in the next call to SubscribeToShard ().
	ContinuationSequenceNumber *string
}

type SubscribeToShardEventStream interface {
	// contains filtered or unexported methods
}

type SubscribeToShardEventStreamMemberInternalFailureException struct {
	Value *InternalFailureException
}

type SubscribeToShardEventStreamMemberKMSAccessDeniedException struct {
	Value *KMSAccessDeniedException
}

type SubscribeToShardEventStreamMemberKMSDisabledException struct {
	Value *KMSDisabledException
}

type SubscribeToShardEventStreamMemberKMSInvalidStateException struct {
	Value *KMSInvalidStateException
}

type SubscribeToShardEventStreamMemberKMSNotFoundException struct {
	Value *KMSNotFoundException
}

type SubscribeToShardEventStreamMemberKMSOptInRequired struct {
	Value *KMSOptInRequired
}

type SubscribeToShardEventStreamMemberKMSThrottlingException struct {
	Value *KMSThrottlingException
}

type SubscribeToShardEventStreamMemberResourceInUseException struct {
	Value *ResourceInUseException
}

type SubscribeToShardEventStreamMemberResourceNotFoundException struct {
	Value *ResourceNotFoundException
}

type SubscribeToShardEventStreamMemberSubscribeToShardEvent struct {
	Value *SubscribeToShardEvent
}

type Tag struct {
	// A unique identifier for the tag. Maximum length: 128 characters. Valid
	// characters: Unicode letters, digits, white space, _ . / = + - % @
	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
}

type UnknownUnionMember struct {
	Tag   string
	Value []byte
}