type APICallRateForCustomerExceededFault struct {
	Message *string
}

type AZMode string

const (
	AZModeSingle_az AZMode = "single-az"
	AZModeCross_az  AZMode = "cross-az"
)

type AuthTokenUpdateStatus string

const (
	AuthTokenUpdateStatusSetting  AuthTokenUpdateStatus = "SETTING"
	AuthTokenUpdateStatusRotating AuthTokenUpdateStatus = "ROTATING"
)

type AuthTokenUpdateStrategyType string

const (
	AuthTokenUpdateStrategyTypeSet    AuthTokenUpdateStrategyType = "SET"
	AuthTokenUpdateStrategyTypeRotate AuthTokenUpdateStrategyType = "ROTATE"
)

type AuthorizationAlreadyExistsFault struct {
	Message *string
}

type AuthorizationNotFoundFault struct {
	Message *string
}

type AutomaticFailoverStatus string

const (
	AutomaticFailoverStatusEnabled   AutomaticFailoverStatus = "enabled"
	AutomaticFailoverStatusDisabled  AutomaticFailoverStatus = "disabled"
	AutomaticFailoverStatusEnabling  AutomaticFailoverStatus = "enabling"
	AutomaticFailoverStatusDisabling AutomaticFailoverStatus = "disabling"
)

type AvailabilityZone struct {
	// The name of the Availability Zone.
	Name *string
}

type CacheCluster struct {
	// The URL of the web page where you can download the latest ElastiCache client
	// library.
	ClientDownloadLandingPage *string
	// Represents a Memcached cluster endpoint which, if Automatic Discovery is enabled
	// on the cluster, can be used by an application to connect to any node in the
	// cluster. The configuration endpoint will always have .cfg in it. Example:
	// mem-3.9dvc4r.cfg.usw2.cache.amazonaws.com:11211
	ConfigurationEndpoint *Endpoint
	// A group of settings that are applied to the cluster in the future, or that are
	// currently being applied.
	PendingModifiedValues *PendingModifiedValues
	// The number of days for which ElastiCache retains automatic cluster snapshots
	// before deleting them. For example, if you set SnapshotRetentionLimit to 5, a
	// snapshot that was taken today is retained for 5 days before being deleted. If
	// the value of SnapshotRetentionLimit is set to zero (0), backups are turned off.
	SnapshotRetentionLimit *int32
	// The date and time when the cluster was created.
	CacheClusterCreateTime *time.Time
	// The ARN (Amazon Resource Name) of the cache cluster.
	ARN *string
	// A flag that enables using an AuthToken (password) when issuing Redis commands.
	// Default: false
	AuthTokenEnabled *bool
	// The replication group to which this cluster belongs. If this field is empty, the
	// cluster is not associated with any replication group.
	ReplicationGroupId *string
	// The current state of this cluster, one of the following values: available,
	// creating, deleted, deleting, incompatible-network, modifying, rebooting cluster
	// nodes, restore-failed, or snapshotting.
	CacheClusterStatus *string
	// A list of VPC Security Groups associated with the cluster.
	SecurityGroups []*SecurityGroupMembership
	// The user-supplied identifier of the cluster. This identifier is a unique key
	// that identifies a cluster.
	CacheClusterId *string
	// A flag that enables in-transit encryption when set to true. You cannot modify
	// the value of TransitEncryptionEnabled after the cluster is created. To enable
	// in-transit encryption on a cluster you must set TransitEncryptionEnabled to true
	// when you create a cluster. Required: Only available when creating a replication
	// group in an Amazon VPC using redis version 3.2.6, 4.x or later. Default: false
	TransitEncryptionEnabled *bool
	// A list of cache security group elements, composed of name and status
	// sub-elements.
	CacheSecurityGroups []*CacheSecurityGroupMembership
	// The number of cache nodes in the cluster. For clusters running Redis, this value
	// must be 1. For clusters running Memcached, this value must be between 1 and 20.
	NumCacheNodes *int32
	// Specifies the weekly time range during which maintenance on the cluster is
	// performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi (24H
	// Clock UTC). The minimum maintenance window is a 60 minute period. Valid values
	// for ddd are:
	//
	//     * sun
	//
	//     * mon
	//
	//     * tue
	//
	//     * wed
	//
	//     * thu
	//
	//     * fri
	//
	//
	// * sat
	//
	// Example: sun:23:00-mon:01:30
	PreferredMaintenanceWindow *string
	// The name of the Availability Zone in which the cluster is located or "Multiple"
	// if the cache nodes are located in different Availability Zones.
	PreferredAvailabilityZone *string
	// This parameter is currently disabled.
	AutoMinorVersionUpgrade *bool
	// Describes a notification topic and its status. Notification topics are used for
	// publishing ElastiCache events to subscribers using Amazon Simple Notification
	// Service (SNS).
	NotificationConfiguration *NotificationConfiguration
	// The date the auth token was last modified
	AuthTokenLastModifiedDate *time.Time
	// The daily time range (in UTC) during which ElastiCache begins taking a daily
	// snapshot of your cluster. Example: 05:00-09:00
	SnapshotWindow *string
	// The name of the cache subnet group associated with the cluster.
	CacheSubnetGroupName *string
	// The name of the cache engine (memcached or redis) to be used for this cluster.
	Engine *string
	// Status of the cache parameter group.
	CacheParameterGroup *CacheParameterGroupStatus
	// A flag that enables encryption at-rest when set to true. You cannot modify the
	// value of AtRestEncryptionEnabled after the cluster is created. To enable at-rest
	// encryption on a cluster you must set AtRestEncryptionEnabled to true when you
	// create a cluster. Required: Only available when creating a replication group in
	// an Amazon VPC using redis version 3.2.6, 4.x or later. Default: false
	AtRestEncryptionEnabled *bool
	// The name of the compute and memory capacity node type for the cluster.  <p>The
	// following node types are supported by ElastiCache. Generally speaking, the
	// current generation types provide more memory and computational power at lower
	// cost when compared to their equivalent previous generation counterparts.</p>
	// <ul> <li> <p>General purpose:</p> <ul> <li> <p>Current generation: </p> <p>
	// <b>M5 node types:</b> <code>cache.m5.large</code>, <code>cache.m5.xlarge</code>,
	// <code>cache.m5.2xlarge</code>, <code>cache.m5.4xlarge</code>,
	// <code>cache.m5.12xlarge</code>, <code>cache.m5.24xlarge</code> </p> <p> <b>M4
	// node types:</b> <code>cache.m4.large</code>, <code>cache.m4.xlarge</code>,
	// <code>cache.m4.2xlarge</code>, <code>cache.m4.4xlarge</code>,
	// <code>cache.m4.10xlarge</code> </p> <p> <b>T3 node types:</b>
	// <code>cache.t3.micro</code>, <code>cache.t3.small</code>,
	// <code>cache.t3.medium</code> </p> <p> <b>T2 node types:</b>
	// <code>cache.t2.micro</code>, <code>cache.t2.small</code>,
	// <code>cache.t2.medium</code> </p> </li> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>T1 node types:</b> <code>cache.t1.micro</code> </p> <p>
	// <b>M1 node types:</b> <code>cache.m1.small</code>, <code>cache.m1.medium</code>,
	// <code>cache.m1.large</code>, <code>cache.m1.xlarge</code> </p> <p> <b>M3 node
	// types:</b> <code>cache.m3.medium</code>, <code>cache.m3.large</code>,
	// <code>cache.m3.xlarge</code>, <code>cache.m3.2xlarge</code> </p> </li> </ul>
	// </li> <li> <p>Compute optimized:</p> <ul> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>C1 node types:</b> <code>cache.c1.xlarge</code> </p>
	// </li> </ul> </li> <li> <p>Memory optimized:</p> <ul> <li> <p>Current generation:
	// </p> <p> <b>R5 node types:</b> <code>cache.r5.large</code>,
	// <code>cache.r5.xlarge</code>, <code>cache.r5.2xlarge</code>,
	// <code>cache.r5.4xlarge</code>, <code>cache.r5.12xlarge</code>,
	// <code>cache.r5.24xlarge</code> </p> <p> <b>R4 node types:</b>
	// <code>cache.r4.large</code>, <code>cache.r4.xlarge</code>,
	// <code>cache.r4.2xlarge</code>, <code>cache.r4.4xlarge</code>,
	// <code>cache.r4.8xlarge</code>, <code>cache.r4.16xlarge</code> </p> </li> <li>
	// <p>Previous generation: (not recommended)</p> <p> <b>M2 node types:</b>
	// <code>cache.m2.xlarge</code>, <code>cache.m2.2xlarge</code>,
	// <code>cache.m2.4xlarge</code> </p> <p> <b>R3 node types:</b>
	// <code>cache.r3.large</code>, <code>cache.r3.xlarge</code>,
	// <code>cache.r3.2xlarge</code>, <code>cache.r3.4xlarge</code>,
	// <code>cache.r3.8xlarge</code> </p> </li> </ul> </li> </ul> <p> <b>Additional
	// node type info</b> </p> <ul> <li> <p>All current generation instance types are
	// created in Amazon VPC by default.</p> </li> <li> <p>Redis append-only files
	// (AOF) are not supported for T1 or T2 instances.</p> </li> <li> <p>Redis Multi-AZ
	// with automatic failover is not supported on T1 instances.</p> </li> <li>
	// <p>Redis configuration variables <code>appendonly</code> and
	// <code>appendfsync</code> are not supported on Redis version 2.8.22 and
	// later.</p> </li> </ul>
	CacheNodeType *string
	// The version of the cache engine that is used in this cluster.
	EngineVersion *string
	// A list of cache nodes that are members of the cluster.
	CacheNodes []*CacheNode
}

type CacheClusterAlreadyExistsFault struct {
	Message *string
}

type CacheClusterNotFoundFault struct {
	Message *string
}

type CacheEngineVersion struct {
	// The name of the cache engine.
	Engine *string
	// The description of the cache engine.
	CacheEngineDescription *string
	// The name of the cache parameter group family associated with this cache engine.
	// Valid values are: memcached1.4 | memcached1.5 | redis2.6 | redis2.8 | redis3.2 |
	// redis4.0 | redis5.0 |
	CacheParameterGroupFamily *string
	// The description of the cache engine version.
	CacheEngineVersionDescription *string
	// The version number of the cache engine.
	EngineVersion *string
}

type CacheNode struct {
	// The ID of the primary node to which this read replica node is synchronized. If
	// this field is empty, this node is not associated with a primary cluster.
	SourceCacheNodeId *string
	// The date and time when the cache node was created.
	CacheNodeCreateTime *time.Time
	// The status of the parameter group applied to this cache node.
	ParameterGroupStatus *string
	// The cache node identifier. A node ID is a numeric identifier (0001, 0002, etc.).
	// The combination of cluster ID and node ID uniquely identifies every cache node
	// used in a customer's AWS account.
	CacheNodeId *string
	// The current state of this cache node, one of the following values: available,
	// creating, rebooting, or deleting.
	CacheNodeStatus *string
	// The hostname for connecting to this cache node.
	Endpoint *Endpoint
	// The Availability Zone where this node was created and now resides.
	CustomerAvailabilityZone *string
}

type CacheNodeTypeSpecificParameter struct {
	// A description of the parameter.
	Description *string
	// Indicates whether a change to the parameter is applied immediately or requires a
	// reboot for the change to be applied. You can force a reboot or wait until the
	// next maintenance window's reboot. For more information, see Rebooting a Cluster
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Clusters.Rebooting.html).
	ChangeType ChangeType
	// Indicates whether (true) or not (false) the parameter can be modified. Some
	// parameters have security or operational implications that prevent them from
	// being changed.
	IsModifiable *bool
	// The name of the parameter.
	ParameterName *string
	// The source of the parameter value.
	Source *string
	// The valid data type for the parameter.
	DataType *string
	// The earliest cache engine version to which the parameter can apply.
	MinimumEngineVersion *string
	// A list of cache node types and their corresponding values for this parameter.
	CacheNodeTypeSpecificValues []*CacheNodeTypeSpecificValue
	// The valid range of values for the parameter.
	AllowedValues *string
}

type CacheNodeTypeSpecificValue struct {
	// The cache node type for which this value applies.
	CacheNodeType *string
	// The value for the cache node type.
	Value *string
}

type CacheNodeUpdateStatus struct {
	// The date when the NodeUpdateStatus was last modified>
	NodeUpdateStatusModifiedDate *time.Time
	// The update status of the node
	NodeUpdateStatus NodeUpdateStatus
	// The end date of the update for a node
	NodeUpdateEndDate *time.Time
	// The start date of the update for a node
	NodeUpdateStartDate *time.Time
	// Reflects whether the update was initiated by the customer or automatically
	// applied
	NodeUpdateInitiatedBy NodeUpdateInitiatedBy
	// The date when the update is triggered
	NodeUpdateInitiatedDate *time.Time
	// The node ID of the cache cluster
	CacheNodeId *string
	// The deletion date of the node
	NodeDeletionDate *time.Time
}

type CacheParameterGroup struct {
	// The description for this cache parameter group.
	Description *string
	// The name of the cache parameter group.
	CacheParameterGroupName *string
	// Indicates whether the parameter group is associated with a Global Datastore
	IsGlobal *bool
	// The name of the cache parameter group family that this cache parameter group is
	// compatible with. Valid values are: memcached1.4 | memcached1.5 | redis2.6 |
	// redis2.8 | redis3.2 | redis4.0 | redis5.0 |
	CacheParameterGroupFamily *string
	// The ARN (Amazon Resource Name) of the cache parameter group.
	ARN *string
}

type CacheParameterGroupAlreadyExistsFault struct {
	Message *string
}

type CacheParameterGroupNotFoundFault struct {
	Message *string
}

type CacheParameterGroupQuotaExceededFault struct {
	Message *string
}

type CacheParameterGroupStatus struct {
	// The name of the cache parameter group.
	CacheParameterGroupName *string
	// The status of parameter updates.
	ParameterApplyStatus *string
	// A list of the cache node IDs which need to be rebooted for parameter changes to
	// be applied. A node ID is a numeric identifier (0001, 0002, etc.).
	CacheNodeIdsToReboot []*string
}

type CacheSecurityGroup struct {
	// The name of the cache security group.
	CacheSecurityGroupName *string
	// The ARN (Amazon Resource Name) of the cache security group.
	ARN *string
	// The AWS account ID of the cache security group owner.
	OwnerId *string
	// The description of the cache security group.
	Description *string
	// A list of Amazon EC2 security groups that are associated with this cache
	// security group.
	EC2SecurityGroups []*EC2SecurityGroup
}

type CacheSecurityGroupAlreadyExistsFault struct {
	Message *string
}

type CacheSecurityGroupMembership struct {
	// The membership status in the cache security group. The status changes when a
	// cache security group is modified, or when the cache security groups assigned to
	// a cluster are modified.
	Status *string
	// The name of the cache security group.
	CacheSecurityGroupName *string
}

type CacheSecurityGroupNotFoundFault struct {
	Message *string
}

type CacheSecurityGroupQuotaExceededFault struct {
	Message *string
}

type CacheSubnetGroup struct {
	// A list of subnets associated with the cache subnet group.
	Subnets []*Subnet
	// The name of the cache subnet group.
	CacheSubnetGroupName *string
	// The ARN (Amazon Resource Name) of the cache subnet group.
	ARN *string
	// The description of the cache subnet group.
	CacheSubnetGroupDescription *string
	// The Amazon Virtual Private Cloud identifier (VPC ID) of the cache subnet group.
	VpcId *string
}

type CacheSubnetGroupAlreadyExistsFault struct {
	Message *string
}

type CacheSubnetGroupInUse struct {
	Message *string
}

type CacheSubnetGroupNotFoundFault struct {
	Message *string
}

type CacheSubnetGroupQuotaExceededFault struct {
	Message *string
}

type CacheSubnetQuotaExceededFault struct {
	Message *string
}

type ChangeType string

const (
	ChangeTypeImmediate      ChangeType = "immediate"
	ChangeTypeRequiresReboot ChangeType = "requires-reboot"
)

type ClusterQuotaForCustomerExceededFault struct {
	Message *string
}

type ConfigureShard struct {
	// A list of PreferredAvailabilityZone strings that specify which availability
	// zones the replication group's nodes are to be in. The nummber of
	// PreferredAvailabilityZone values must equal the value of NewReplicaCount plus 1
	// to account for the primary node. If this member of ReplicaConfiguration is
	// omitted, ElastiCache for Redis selects the availability zone for each of the
	// replicas.
	PreferredAvailabilityZones []*string
	// The number of replicas you want in this node group at the end of this operation.
	// The maximum value for NewReplicaCount is 5. The minimum value depends upon the
	// type of Redis replication group you are working with. The minimum number of
	// replicas in a shard or replication group is:
	//
	//     * Redis (cluster mode
	// disabled)
	//
	//         * If Multi-AZ: 1
	//
	//         * If Multi-AZ: 0
	//
	//     * Redis
	// (cluster mode enabled): 0 (though you will not be able to failover to a replica
	// if your primary node fails)
	NewReplicaCount *int32
	// The 4-digit id for the node group you are configuring. For Redis (cluster mode
	// disabled) replication groups, the node group id is always 0001. To find a Redis
	// (cluster mode enabled)'s node group's (shard's) id, see Finding a Shard's Id
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/shard-find-id.html).
	NodeGroupId *string
}

type CustomerNodeEndpoint struct {
	// The address of the node endpoint
	Address *string
	// The port of the node endpoint
	Port *int32
}

type EC2SecurityGroup struct {
	// The name of the Amazon EC2 security group.
	EC2SecurityGroupName *string
	// The status of the Amazon EC2 security group.
	Status *string
	// The AWS account ID of the Amazon EC2 security group owner.
	EC2SecurityGroupOwnerId *string
}

type Endpoint struct {
	// The port number that the cache engine is listening on.
	Port *int32
	// The DNS hostname of the cache node.
	Address *string
}

type EngineDefaults struct {
	// Specifies the name of the cache parameter group family to which the engine
	// default parameters apply. Valid values are: memcached1.4 | memcached1.5 |
	// redis2.6 | redis2.8 | redis3.2 | redis4.0 | redis5.0 |
	CacheParameterGroupFamily *string
	// Provides an identifier to allow retrieval of paginated results.
	Marker *string
	// A list of parameters specific to a particular cache node type. Each element in
	// the list contains detailed information about one parameter.
	CacheNodeTypeSpecificParameters []*CacheNodeTypeSpecificParameter
	// Contains a list of engine default parameters.
	Parameters []*Parameter
}

type Event struct {
	// The date and time when the event occurred.
	Date *time.Time
	// The identifier for the source of the event. For example, if the event occurred
	// at the cluster level, the identifier would be the name of the cluster.
	SourceIdentifier *string
	// Specifies the origin of this event - a cluster, a parameter group, a security
	// group, etc.
	SourceType SourceType
	// The text of the event.
	Message *string
}

type GlobalNodeGroup struct {
	// The keyspace for this node group
	Slots *string
	// The name of the global node group
	GlobalNodeGroupId *string
}

type GlobalReplicationGroup struct {
	// A flag that enables in-transit encryption when set to true.  You cannot modify
	// the value of <code>TransitEncryptionEnabled</code> after the cluster is created.
	// To enable in-transit encryption on a cluster you must set
	// <code>TransitEncryptionEnabled</code> to true when you create a cluster. </p>
	TransitEncryptionEnabled *bool
	// A flag that indicates whether the Global Datastore is cluster enabled.
	ClusterEnabled *bool
	// The optional description of the Global Datastore
	GlobalReplicationGroupDescription *string
	// The replication groups that comprise the Global Datastore.
	Members []*GlobalReplicationGroupMember
	// The name of the Global Datastore
	GlobalReplicationGroupId *string
	// The ARN (Amazon Resource Name) of the global replication group.
	ARN *string
	// The Elasticache engine. For Redis only.
	Engine *string
	// A flag that enables encryption at rest when set to true. You cannot modify the
	// value of AtRestEncryptionEnabled after the replication group is created. To
	// enable encryption at rest on a replication group you must set
	// AtRestEncryptionEnabled to true when you create the replication group. Required:
	// Only available when creating a replication group in an Amazon VPC using redis
	// version 3.2.6, 4.x or later.
	AtRestEncryptionEnabled *bool
	// A flag that enables using an AuthToken (password) when issuing Redis commands.
	// Default: false
	AuthTokenEnabled *bool
	// The status of the Global Datastore
	Status *string
	// Indicates the slot configuration and global identifier for each slice group.
	GlobalNodeGroups []*GlobalNodeGroup
	// The Elasticache Redis engine version. For preview, it is Redis version 5.0.5
	// only.
	EngineVersion *string
	// The cache node type of the Global Datastore
	CacheNodeType *string
}

type GlobalReplicationGroupAlreadyExistsFault struct {
	Message *string
}

type GlobalReplicationGroupInfo struct {
	// The role of the replication group in a Global Datastore. Can be primary or
	// secondary.
	GlobalReplicationGroupMemberRole *string
	// The name of the Global Datastore
	GlobalReplicationGroupId *string
}

type GlobalReplicationGroupMember struct {
	// Indicates the role of the replication group, primary or secondary.
	Role *string
	// The AWS region of the Global Datastore member.
	ReplicationGroupRegion *string
	// The status of the membership of the replication group.
	Status *string
	// The replication group id of the Global Datastore member.
	ReplicationGroupId *string
	// Indicates whether automatic failover is enabled for the replication group.
	AutomaticFailover AutomaticFailoverStatus
}

type GlobalReplicationGroupNotFoundFault struct {
	Message *string
}

type InsufficientCacheClusterCapacityFault struct {
	Message *string
}

type InvalidARNFault struct {
	Message *string
}

type InvalidCacheClusterStateFault struct {
	Message *string
}

type InvalidCacheParameterGroupStateFault struct {
	Message *string
}

type InvalidCacheSecurityGroupStateFault struct {
	Message *string
}

type InvalidGlobalReplicationGroupStateFault struct {
	Message *string
}

type InvalidKMSKeyFault struct {
	Message *string
}

type InvalidParameterCombinationException struct {
	Message *string
}

type InvalidParameterValueException struct {
	Message *string
}

type InvalidReplicationGroupStateFault struct {
	Message *string
}

type InvalidSnapshotStateFault struct {
	Message *string
}

type InvalidSubnet struct {
	Message *string
}

type InvalidVPCNetworkStateFault struct {
	Message *string
}

type MultiAZStatus string

const (
	MultiAZStatusEnabled  MultiAZStatus = "enabled"
	MultiAZStatusDisabled MultiAZStatus = "disabled"
)

type NoOperationFault struct {
	Message *string
}

type NodeGroup struct {
	// A list containing information about individual nodes within the node group
	// (shard).
	NodeGroupMembers []*NodeGroupMember
	// The endpoint of the primary node in this node group (shard).
	PrimaryEndpoint *Endpoint
	// The keyspace for this node group (shard).
	Slots *string
	// The current state of this replication group - creating, available, modifying,
	// deleting.
	Status *string
	// The identifier for the node group (shard). A Redis (cluster mode disabled)
	// replication group contains only 1 node group; therefore, the node group ID is
	// 0001. A Redis (cluster mode enabled) replication group contains 1 to 90 node
	// groups numbered 0001 to 0090. Optionally, the user can provide the id for a node
	// group.
	NodeGroupId *string
	// The endpoint of the replica nodes in this node group (shard).
	ReaderEndpoint *Endpoint
}

type NodeGroupConfiguration struct {
	// Either the ElastiCache for Redis supplied 4-digit id or a user supplied id for
	// the node group these configuration values apply to.
	NodeGroupId *string
	// A list of Availability Zones to be used for the read replicas. The number of
	// Availability Zones in this list must match the value of ReplicaCount or
	// ReplicasPerNodeGroup if not specified.
	ReplicaAvailabilityZones []*string
	// The number of read replica nodes in this node group (shard).
	ReplicaCount *int32
	// The Availability Zone where the primary node of this node group (shard) is
	// launched.
	PrimaryAvailabilityZone *string
	// A string that specifies the keyspace for a particular node group. Keyspaces
	// range from 0 to 16,383. The string is in the format startkey-endkey. Example:
	// "0-3999"
	Slots *string
}

type NodeGroupMember struct {
	// The role that is currently assigned to the node - primary or replica. This
	// member is only applicable for Redis (cluster mode disabled) replication groups.
	CurrentRole *string
	// The ID of the node within its cluster. A node ID is a numeric identifier (0001,
	// 0002, etc.).
	CacheNodeId *string
	// The name of the Availability Zone in which the node is located.
	PreferredAvailabilityZone *string
	// The information required for client programs to connect to a node for read
	// operations. The read endpoint is only applicable on Redis (cluster mode
	// disabled) clusters.
	ReadEndpoint *Endpoint
	// The ID of the cluster to which the node belongs.
	CacheClusterId *string
}

type NodeGroupMemberUpdateStatus struct {
	// The update status of the node
	NodeUpdateStatus NodeUpdateStatus
	// The start date of the update for a node
	NodeUpdateStartDate *time.Time
	// The cache cluster ID
	CacheClusterId *string
	// The deletion date of the node
	NodeDeletionDate *time.Time
	// The date when the NodeUpdateStatus was last modified
	NodeUpdateStatusModifiedDate *time.Time
	// Reflects whether the update was initiated by the customer or automatically
	// applied
	NodeUpdateInitiatedBy NodeUpdateInitiatedBy
	// The node ID of the cache cluster
	CacheNodeId *string
	// The date when the update is triggered
	NodeUpdateInitiatedDate *time.Time
	// The end date of the update for a node
	NodeUpdateEndDate *time.Time
}

type NodeGroupNotFoundFault struct {
	Message *string
}

type NodeGroupUpdateStatus struct {
	// The ID of the node group
	NodeGroupId *string
	// The status of the service update on the node group member
	NodeGroupMemberUpdateStatus []*NodeGroupMemberUpdateStatus
}

type NodeGroupsPerReplicationGroupQuotaExceededFault struct {
	Message *string
}

type NodeQuotaForClusterExceededFault struct {
	Message *string
}

type NodeQuotaForCustomerExceededFault struct {
	Message *string
}

type NodeSnapshot struct {
	// The cache node identifier for the node in the source cluster.
	CacheNodeId *string
	// The date and time when the source node's metadata and cache data set was
	// obtained for the snapshot.
	SnapshotCreateTime *time.Time
	// The configuration for the source node group (shard).
	NodeGroupConfiguration *NodeGroupConfiguration
	// The date and time when the cache node was created in the source cluster.
	CacheNodeCreateTime *time.Time
	// A unique identifier for the source cluster.
	CacheClusterId *string
	// A unique identifier for the source node group (shard).
	NodeGroupId *string
	// The size of the cache on the source cache node.
	CacheSize *string
}

type NodeUpdateInitiatedBy string

const (
	NodeUpdateInitiatedBySystem   NodeUpdateInitiatedBy = "system"
	NodeUpdateInitiatedByCustomer NodeUpdateInitiatedBy = "customer"
)

type NodeUpdateStatus string

const (
	NodeUpdateStatusNot_applied      NodeUpdateStatus = "not-applied"
	NodeUpdateStatusWaiting_to_start NodeUpdateStatus = "waiting-to-start"
	NodeUpdateStatusIn_progress      NodeUpdateStatus = "in-progress"
	NodeUpdateStatusStopping         NodeUpdateStatus = "stopping"
	NodeUpdateStatusStopped          NodeUpdateStatus = "stopped"
	NodeUpdateStatusComplete         NodeUpdateStatus = "complete"
)

type NotificationConfiguration struct {
	// The current state of the topic.
	TopicStatus *string
	// The Amazon Resource Name (ARN) that identifies the topic.
	TopicArn *string
}

type Parameter struct {
	// A description of the parameter.
	Description *string
	// Indicates whether a change to the parameter is applied immediately or requires a
	// reboot for the change to be applied. You can force a reboot or wait until the
	// next maintenance window's reboot. For more information, see Rebooting a Cluster
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Clusters.Rebooting.html).
	ChangeType ChangeType
	// Indicates whether (true) or not (false) the parameter can be modified. Some
	// parameters have security or operational implications that prevent them from
	// being changed.
	IsModifiable *bool
	// The name of the parameter.
	ParameterName *string
	// The source of the parameter.
	Source *string
	// The valid data type for the parameter.
	DataType *string
	// The earliest cache engine version to which the parameter can apply.
	MinimumEngineVersion *string
	// The valid range of values for the parameter.
	AllowedValues *string
	// The value of the parameter.
	ParameterValue *string
}

type ParameterNameValue struct {
	// The value of the parameter.
	ParameterValue *string
	// The name of the parameter.
	ParameterName *string
}

type PendingAutomaticFailoverStatus string

const (
	PendingAutomaticFailoverStatusEnabled  PendingAutomaticFailoverStatus = "enabled"
	PendingAutomaticFailoverStatusDisabled PendingAutomaticFailoverStatus = "disabled"
)

type PendingModifiedValues struct {
	// The new number of cache nodes for the cluster. For clusters running Redis, this
	// value must be 1. For clusters running Memcached, this value must be between 1
	// and 20.
	NumCacheNodes *int32
	// A list of cache node IDs that are being removed (or will be removed) from the
	// cluster. A node ID is a 4-digit numeric identifier (0001, 0002, etc.).
	CacheNodeIdsToRemove []*string
	// The new cache engine version that the cluster runs.
	EngineVersion *string
	// The cache node type that this cluster or replication group is scaled to.
	CacheNodeType *string
	// The auth token status
	AuthTokenStatus AuthTokenUpdateStatus
}

type ProcessedUpdateAction struct {
	// The unique ID of the service update
	ServiceUpdateName *string
	// The ID of the cache cluster
	CacheClusterId *string
	// The ID of the replication group
	ReplicationGroupId *string
	// The status of the update action on the Redis cluster
	UpdateActionStatus UpdateActionStatus
}

type RecurringCharge struct {
	// The monetary amount of the recurring charge.
	RecurringChargeAmount *float64
	// The frequency of the recurring charge.
	RecurringChargeFrequency *string
}

type RegionalConfiguration struct {
	// The AWS region where the cluster is stored
	ReplicationGroupRegion *string
	// A list of PreferredAvailabilityZones objects that specifies the configuration of
	// a node group in the resharded cluster.
	ReshardingConfiguration []*ReshardingConfiguration
	// The name of the secondary cluster
	ReplicationGroupId *string
}

type ReplicationGroup struct {
	// Indicates the status of automatic failover for this Redis replication group.
	AutomaticFailover AutomaticFailoverStatus
	// The date the auth token was last modified
	AuthTokenLastModifiedDate *time.Time
	// The configuration endpoint for this replication group. Use the configuration
	// endpoint to connect to this replication group.
	ConfigurationEndpoint *Endpoint
	// The names of all the cache clusters that are part of this replication group.
	MemberClusters []*string
	// The name of the Global Datastore and role of this replication group in the
	// Global Datastore.
	GlobalReplicationGroupInfo *GlobalReplicationGroupInfo
	// The current state of this replication group - creating, available, modifying,
	// deleting, create-failed, snapshotting.
	Status *string
	// A flag indicating if you have Multi-AZ enabled to enhance fault tolerance. For
	// more information, see Minimizing Downtime: Multi-AZ
	// (http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/AutoFailover.html)
	MultiAZ MultiAZStatus
	// The name of the compute and memory capacity node type for each node in the
	// replication group.
	CacheNodeType *string
	// A flag that enables in-transit encryption when set to true. You cannot modify
	// the value of TransitEncryptionEnabled after the cluster is created. To enable
	// in-transit encryption on a cluster you must set TransitEncryptionEnabled to true
	// when you create a cluster. Required: Only available when creating a replication
	// group in an Amazon VPC using redis version 3.2.6, 4.x or later. Default: false
	TransitEncryptionEnabled *bool
	// The identifier for the replication group.
	ReplicationGroupId *string
	// A flag that enables encryption at-rest when set to true. You cannot modify the
	// value of AtRestEncryptionEnabled after the cluster is created. To enable
	// encryption at-rest on a cluster you must set AtRestEncryptionEnabled to true
	// when you create a cluster. Required: Only available when creating a replication
	// group in an Amazon VPC using redis version 3.2.6, 4.x or later. Default: false
	AtRestEncryptionEnabled *bool
	// A flag that enables using an AuthToken (password) when issuing Redis commands.
	// Default: false
	AuthTokenEnabled *bool
	// The user supplied description of the replication group.
	Description *string
	// A list of node groups in this replication group. For Redis (cluster mode
	// disabled) replication groups, this is a single-element list. For Redis (cluster
	// mode enabled) replication groups, the list contains an entry for each node group
	// (shard).
	NodeGroups []*NodeGroup
	// The ARN (Amazon Resource Name) of the replication group.
	ARN *string
	// The daily time range (in UTC) during which ElastiCache begins taking a daily
	// snapshot of your node group (shard). Example: 05:00-09:00 If you do not specify
	// this parameter, ElastiCache automatically chooses an appropriate time range.
	// This parameter is only valid if the Engine parameter is redis.
	SnapshotWindow *string
	// A flag indicating whether or not this replication group is cluster enabled;
	// i.e., whether its data can be partitioned across multiple shards (API/CLI: node
	// groups). Valid values: true | false
	ClusterEnabled *bool
	// A group of settings to be applied to the replication group, either immediately
	// or during the next maintenance window.
	PendingModifiedValues *ReplicationGroupPendingModifiedValues
	// The number of days for which ElastiCache retains automatic cluster snapshots
	// before deleting them. For example, if you set SnapshotRetentionLimit to 5, a
	// snapshot that was taken today is retained for 5 days before being deleted. If
	// the value of SnapshotRetentionLimit is set to zero (0), backups are turned off.
	SnapshotRetentionLimit *int32
	// The cluster ID that is used as the daily snapshot source for the replication
	// group.
	SnapshottingClusterId *string
	// The ID of the KMS key used to encrypt the disk in the cluster.
	KmsKeyId *string
}

type ReplicationGroupAlreadyExistsFault struct {
	Message *string
}

type ReplicationGroupAlreadyUnderMigrationFault struct {
	Message *string
}

type ReplicationGroupNotFoundFault struct {
	Message *string
}

type ReplicationGroupNotUnderMigrationFault struct {
	Message *string
}

type ReplicationGroupPendingModifiedValues struct {
	// The status of an online resharding operation.
	Resharding *ReshardingStatus
	// The primary cluster ID that is applied immediately (if --apply-immediately was
	// specified), or during the next maintenance window.
	PrimaryClusterId *string
	// Indicates the status of automatic failover for this Redis replication group.
	AutomaticFailoverStatus PendingAutomaticFailoverStatus
	// The auth token status
	AuthTokenStatus AuthTokenUpdateStatus
}

type ReservedCacheNode struct {
	// The fixed price charged for this reserved cache node.
	FixedPrice *float64
	// The Amazon Resource Name (ARN) of the reserved cache node. Example:
	// arn:aws:elasticache:us-east-1:123456789012:reserved-instance:ri-2017-03-27-08-33-25-582
	ReservationARN *string
	// The time the reservation started.
	StartTime *time.Time
	// The state of the reserved cache node.
	State *string
	// The cache node type for the reserved cache nodes.  <p>The following node types
	// are supported by ElastiCache. Generally speaking, the current generation types
	// provide more memory and computational power at lower cost when compared to their
	// equivalent previous generation counterparts.</p> <ul> <li> <p>General
	// purpose:</p> <ul> <li> <p>Current generation: </p> <p> <b>M5 node types:</b>
	// <code>cache.m5.large</code>, <code>cache.m5.xlarge</code>,
	// <code>cache.m5.2xlarge</code>, <code>cache.m5.4xlarge</code>,
	// <code>cache.m5.12xlarge</code>, <code>cache.m5.24xlarge</code> </p> <p> <b>M4
	// node types:</b> <code>cache.m4.large</code>, <code>cache.m4.xlarge</code>,
	// <code>cache.m4.2xlarge</code>, <code>cache.m4.4xlarge</code>,
	// <code>cache.m4.10xlarge</code> </p> <p> <b>T3 node types:</b>
	// <code>cache.t3.micro</code>, <code>cache.t3.small</code>,
	// <code>cache.t3.medium</code> </p> <p> <b>T2 node types:</b>
	// <code>cache.t2.micro</code>, <code>cache.t2.small</code>,
	// <code>cache.t2.medium</code> </p> </li> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>T1 node types:</b> <code>cache.t1.micro</code> </p> <p>
	// <b>M1 node types:</b> <code>cache.m1.small</code>, <code>cache.m1.medium</code>,
	// <code>cache.m1.large</code>, <code>cache.m1.xlarge</code> </p> <p> <b>M3 node
	// types:</b> <code>cache.m3.medium</code>, <code>cache.m3.large</code>,
	// <code>cache.m3.xlarge</code>, <code>cache.m3.2xlarge</code> </p> </li> </ul>
	// </li> <li> <p>Compute optimized:</p> <ul> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>C1 node types:</b> <code>cache.c1.xlarge</code> </p>
	// </li> </ul> </li> <li> <p>Memory optimized:</p> <ul> <li> <p>Current generation:
	// </p> <p> <b>R5 node types:</b> <code>cache.r5.large</code>,
	// <code>cache.r5.xlarge</code>, <code>cache.r5.2xlarge</code>,
	// <code>cache.r5.4xlarge</code>, <code>cache.r5.12xlarge</code>,
	// <code>cache.r5.24xlarge</code> </p> <p> <b>R4 node types:</b>
	// <code>cache.r4.large</code>, <code>cache.r4.xlarge</code>,
	// <code>cache.r4.2xlarge</code>, <code>cache.r4.4xlarge</code>,
	// <code>cache.r4.8xlarge</code>, <code>cache.r4.16xlarge</code> </p> </li> <li>
	// <p>Previous generation: (not recommended)</p> <p> <b>M2 node types:</b>
	// <code>cache.m2.xlarge</code>, <code>cache.m2.2xlarge</code>,
	// <code>cache.m2.4xlarge</code> </p> <p> <b>R3 node types:</b>
	// <code>cache.r3.large</code>, <code>cache.r3.xlarge</code>,
	// <code>cache.r3.2xlarge</code>, <code>cache.r3.4xlarge</code>,
	// <code>cache.r3.8xlarge</code> </p> </li> </ul> </li> </ul> <p> <b>Additional
	// node type info</b> </p> <ul> <li> <p>All current generation instance types are
	// created in Amazon VPC by default.</p> </li> <li> <p>Redis append-only files
	// (AOF) are not supported for T1 or T2 instances.</p> </li> <li> <p>Redis Multi-AZ
	// with automatic failover is not supported on T1 instances.</p> </li> <li>
	// <p>Redis configuration variables <code>appendonly</code> and
	// <code>appendfsync</code> are not supported on Redis version 2.8.22 and
	// later.</p> </li> </ul>
	CacheNodeType *string
	// The offering type of this reserved cache node.
	OfferingType *string
	// The offering identifier.
	ReservedCacheNodesOfferingId *string
	// The duration of the reservation in seconds.
	Duration *int32
	// The hourly price charged for this reserved cache node.
	UsagePrice *float64
	// The number of cache nodes that have been reserved.
	CacheNodeCount *int32
	// The unique identifier for the reservation.
	ReservedCacheNodeId *string
	// The recurring price charged to run this reserved cache node.
	RecurringCharges []*RecurringCharge
	// The description of the reserved cache node.
	ProductDescription *string
}

type ReservedCacheNodeAlreadyExistsFault struct {
	Message *string
}

type ReservedCacheNodeNotFoundFault struct {
	Message *string
}

type ReservedCacheNodeQuotaExceededFault struct {
	Message *string
}

type ReservedCacheNodesOffering struct {
	// The cache node type for the reserved cache node. The following node types are
	// supported by ElastiCache. Generally speaking, the current generation types
	// provide more memory and computational power at lower cost when compared to their
	// equivalent previous generation counterparts.
	//
	//     * General purpose:
	//
	//         *
	// Current generation:  <p> <b>M5 node types:</b> <code>cache.m5.large</code>,
	// <code>cache.m5.xlarge</code>, <code>cache.m5.2xlarge</code>,
	// <code>cache.m5.4xlarge</code>, <code>cache.m5.12xlarge</code>,
	// <code>cache.m5.24xlarge</code> </p> <p> <b>M4 node types:</b>
	// <code>cache.m4.large</code>, <code>cache.m4.xlarge</code>,
	// <code>cache.m4.2xlarge</code>, <code>cache.m4.4xlarge</code>,
	// <code>cache.m4.10xlarge</code> </p> <p> <b>T3 node types:</b>
	// <code>cache.t3.micro</code>, <code>cache.t3.small</code>,
	// <code>cache.t3.medium</code> </p> <p> <b>T2 node types:</b>
	// <code>cache.t2.micro</code>, <code>cache.t2.small</code>,
	// <code>cache.t2.medium</code> </p> </li> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>T1 node types:</b> <code>cache.t1.micro</code> </p> <p>
	// <b>M1 node types:</b> <code>cache.m1.small</code>, <code>cache.m1.medium</code>,
	// <code>cache.m1.large</code>, <code>cache.m1.xlarge</code> </p> <p> <b>M3 node
	// types:</b> <code>cache.m3.medium</code>, <code>cache.m3.large</code>,
	// <code>cache.m3.xlarge</code>, <code>cache.m3.2xlarge</code> </p> </li> </ul>
	// </li> <li> <p>Compute optimized:</p> <ul> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>C1 node types:</b> <code>cache.c1.xlarge</code> </p>
	// </li> </ul> </li> <li> <p>Memory optimized:</p> <ul> <li> <p>Current generation:
	// </p> <p> <b>R5 node types:</b> <code>cache.r5.large</code>,
	// <code>cache.r5.xlarge</code>, <code>cache.r5.2xlarge</code>,
	// <code>cache.r5.4xlarge</code>, <code>cache.r5.12xlarge</code>,
	// <code>cache.r5.24xlarge</code> </p> <p> <b>R4 node types:</b>
	// <code>cache.r4.large</code>, <code>cache.r4.xlarge</code>,
	// <code>cache.r4.2xlarge</code>, <code>cache.r4.4xlarge</code>,
	// <code>cache.r4.8xlarge</code>, <code>cache.r4.16xlarge</code> </p> </li> <li>
	// <p>Previous generation: (not recommended)</p> <p> <b>M2 node types:</b>
	// <code>cache.m2.xlarge</code>, <code>cache.m2.2xlarge</code>,
	// <code>cache.m2.4xlarge</code> </p> <p> <b>R3 node types:</b>
	// <code>cache.r3.large</code>, <code>cache.r3.xlarge</code>,
	// <code>cache.r3.2xlarge</code>, <code>cache.r3.4xlarge</code>,
	// <code>cache.r3.8xlarge</code> </p> </li> </ul> </li> </ul> <p> <b>Additional
	// node type info</b> </p> <ul> <li> <p>All current generation instance types are
	// created in Amazon VPC by default.</p> </li> <li> <p>Redis append-only files
	// (AOF) are not supported for T1 or T2 instances.</p> </li> <li> <p>Redis Multi-AZ
	// with automatic failover is not supported on T1 instances.</p> </li> <li>
	// <p>Redis configuration variables <code>appendonly</code> and
	// <code>appendfsync</code> are not supported on Redis version 2.8.22 and
	// later.</p> </li> </ul>
	CacheNodeType *string
	// The duration of the offering. in seconds.
	Duration *int32
	// The cache engine used by the offering.
	ProductDescription *string
	// The recurring price charged to run this reserved cache node.
	RecurringCharges []*RecurringCharge
	// The offering type.
	OfferingType *string
	// The fixed price charged for this offering.
	FixedPrice *float64
	// A unique identifier for the reserved cache node offering.
	ReservedCacheNodesOfferingId *string
	// The hourly price charged for this offering.
	UsagePrice *float64
}

type ReservedCacheNodesOfferingNotFoundFault struct {
	Message *string
}

type ReshardingConfiguration struct {
	// Either the ElastiCache for Redis supplied 4-digit id or a user supplied id for
	// the node group these configuration values apply to.
	NodeGroupId *string
	// A list of preferred availability zones for the nodes in this cluster.
	PreferredAvailabilityZones []*string
}

type ReshardingStatus struct {
	// Represents the progress of an online resharding operation.
	SlotMigration *SlotMigration
}

type SecurityGroupMembership struct {
	// The identifier of the cache security group.
	SecurityGroupId *string
	// The status of the cache security group membership. The status changes whenever a
	// cache security group is modified, or when the cache security groups assigned to
	// a cluster are modified.
	Status *string
}

type ServiceLinkedRoleNotFoundFault struct {
	Message *string
}

type ServiceUpdate struct {
	// Indicates whether the service update will be automatically applied once the
	// recommended apply-by date has expired.
	AutoUpdateAfterRecommendedApplyByDate *bool
	// The severity of the service update
	ServiceUpdateSeverity ServiceUpdateSeverity
	// The date after which the service update is no longer available
	ServiceUpdateEndDate *time.Time
	// The Elasticache engine to which the update applies. Either Redis or Memcached
	Engine *string
	// The unique ID of the service update
	ServiceUpdateName *string
	// The Elasticache engine version to which the update applies. Either Redis or
	// Memcached engine version
	EngineVersion *string
	// The status of the service update
	ServiceUpdateStatus ServiceUpdateStatus
	// The date when the service update is initially available
	ServiceUpdateReleaseDate *time.Time
	// Reflects the nature of the service update
	ServiceUpdateType ServiceUpdateType
	// Provides details of the service update
	ServiceUpdateDescription *string
	// The recommendend date to apply the service update in order to ensure compliance.
	// For information on compliance, see Self-Service Security Updates for Compliance
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/elasticache-compliance.html#elasticache-compliance-self-service).
	ServiceUpdateRecommendedApplyByDate *time.Time
	// The estimated length of time the service update will take
	EstimatedUpdateTime *string
}

type ServiceUpdateNotFoundFault struct {
	Message *string
}

type ServiceUpdateSeverity string

const (
	ServiceUpdateSeverityCritical  ServiceUpdateSeverity = "critical"
	ServiceUpdateSeverityImportant ServiceUpdateSeverity = "important"
	ServiceUpdateSeverityMedium    ServiceUpdateSeverity = "medium"
	ServiceUpdateSeverityLow       ServiceUpdateSeverity = "low"
)

type ServiceUpdateStatus string

const (
	ServiceUpdateStatusAvailable ServiceUpdateStatus = "available"
	ServiceUpdateStatusCancelled ServiceUpdateStatus = "cancelled"
	ServiceUpdateStatusExpired   ServiceUpdateStatus = "expired"
)

type ServiceUpdateType string

const (
	ServiceUpdateTypeSecurity_update ServiceUpdateType = "security-update"
)

type SlaMet string

const (
	SlaMetYes SlaMet = "yes"
	SlaMetNo  SlaMet = "no"
	SlaMetNa  SlaMet = "n/a"
)

type SlotMigration struct {
	// The percentage of the slot migration that is complete.
	ProgressPercentage *float64
}

type Snapshot struct {
	// The name of the cache subnet group associated with the source cluster.
	CacheSubnetGroupName *string
	// The ID of the KMS key used to encrypt the snapshot.
	KmsKeyId *string
	// The version of the cache engine version that is used by the source cluster.
	EngineVersion *string
	// Indicates whether the snapshot is from an automatic backup (automated) or was
	// created manually (manual).
	SnapshotSource *string
	// The name of the Availability Zone in which the source cluster is located.
	PreferredAvailabilityZone *string
	// Specifies the weekly time range during which maintenance on the cluster is
	// performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi (24H
	// Clock UTC). The minimum maintenance window is a 60 minute period. Valid values
	// for ddd are:
	//
	//     * sun
	//
	//     * mon
	//
	//     * tue
	//
	//     * wed
	//
	//     * thu
	//
	//     * fri
	//
	//
	// * sat
	//
	// Example: sun:23:00-mon:01:30
	PreferredMaintenanceWindow *string
	// This parameter is currently disabled.
	AutoMinorVersionUpgrade *bool
	// The Amazon Virtual Private Cloud identifier (VPC ID) of the cache subnet group
	// for the source cluster.
	VpcId *string
	// The cache parameter group that is associated with the source cluster.
	CacheParameterGroupName *string
	// The date and time when the source cluster was created.
	CacheClusterCreateTime *time.Time
	// For an automatic snapshot, the number of days for which ElastiCache retains the
	// snapshot before deleting it. For manual snapshots, this field reflects the
	// SnapshotRetentionLimit for the source cluster when the snapshot was created.
	// This field is otherwise ignored: Manual snapshots do not expire, and can only be
	// deleted using the DeleteSnapshot operation. Important If the value of
	// SnapshotRetentionLimit is set to zero (0), backups are turned off.
	SnapshotRetentionLimit *int32
	// The status of the snapshot. Valid values: creating | available | restoring |
	// copying | deleting.
	SnapshotStatus *string
	// The name of the compute and memory capacity node type for the source cluster.
	// <p>The following node types are supported by ElastiCache. Generally speaking,
	// the current generation types provide more memory and computational power at
	// lower cost when compared to their equivalent previous generation
	// counterparts.</p> <ul> <li> <p>General purpose:</p> <ul> <li> <p>Current
	// generation: </p> <p> <b>M5 node types:</b> <code>cache.m5.large</code>,
	// <code>cache.m5.xlarge</code>, <code>cache.m5.2xlarge</code>,
	// <code>cache.m5.4xlarge</code>, <code>cache.m5.12xlarge</code>,
	// <code>cache.m5.24xlarge</code> </p> <p> <b>M4 node types:</b>
	// <code>cache.m4.large</code>, <code>cache.m4.xlarge</code>,
	// <code>cache.m4.2xlarge</code>, <code>cache.m4.4xlarge</code>,
	// <code>cache.m4.10xlarge</code> </p> <p> <b>T3 node types:</b>
	// <code>cache.t3.micro</code>, <code>cache.t3.small</code>,
	// <code>cache.t3.medium</code> </p> <p> <b>T2 node types:</b>
	// <code>cache.t2.micro</code>, <code>cache.t2.small</code>,
	// <code>cache.t2.medium</code> </p> </li> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>T1 node types:</b> <code>cache.t1.micro</code> </p> <p>
	// <b>M1 node types:</b> <code>cache.m1.small</code>, <code>cache.m1.medium</code>,
	// <code>cache.m1.large</code>, <code>cache.m1.xlarge</code> </p> <p> <b>M3 node
	// types:</b> <code>cache.m3.medium</code>, <code>cache.m3.large</code>,
	// <code>cache.m3.xlarge</code>, <code>cache.m3.2xlarge</code> </p> </li> </ul>
	// </li> <li> <p>Compute optimized:</p> <ul> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>C1 node types:</b> <code>cache.c1.xlarge</code> </p>
	// </li> </ul> </li> <li> <p>Memory optimized:</p> <ul> <li> <p>Current generation:
	// </p> <p> <b>R5 node types:</b> <code>cache.r5.large</code>,
	// <code>cache.r5.xlarge</code>, <code>cache.r5.2xlarge</code>,
	// <code>cache.r5.4xlarge</code>, <code>cache.r5.12xlarge</code>,
	// <code>cache.r5.24xlarge</code> </p> <p> <b>R4 node types:</b>
	// <code>cache.r4.large</code>, <code>cache.r4.xlarge</code>,
	// <code>cache.r4.2xlarge</code>, <code>cache.r4.4xlarge</code>,
	// <code>cache.r4.8xlarge</code>, <code>cache.r4.16xlarge</code> </p> </li> <li>
	// <p>Previous generation: (not recommended)</p> <p> <b>M2 node types:</b>
	// <code>cache.m2.xlarge</code>, <code>cache.m2.2xlarge</code>,
	// <code>cache.m2.4xlarge</code> </p> <p> <b>R3 node types:</b>
	// <code>cache.r3.large</code>, <code>cache.r3.xlarge</code>,
	// <code>cache.r3.2xlarge</code>, <code>cache.r3.4xlarge</code>,
	// <code>cache.r3.8xlarge</code> </p> </li> </ul> </li> </ul> <p> <b>Additional
	// node type info</b> </p> <ul> <li> <p>All current generation instance types are
	// created in Amazon VPC by default.</p> </li> <li> <p>Redis append-only files
	// (AOF) are not supported for T1 or T2 instances.</p> </li> <li> <p>Redis Multi-AZ
	// with automatic failover is not supported on T1 instances.</p> </li> <li>
	// <p>Redis configuration variables <code>appendonly</code> and
	// <code>appendfsync</code> are not supported on Redis version 2.8.22 and
	// later.</p> </li> </ul>
	CacheNodeType *string
	// The daily time range during which ElastiCache takes daily snapshots of the
	// source cluster.
	SnapshotWindow *string
	// A list of the cache nodes in the source cluster.
	NodeSnapshots []*NodeSnapshot
	// The number of cache nodes in the source cluster. For clusters running Redis,
	// this value must be 1. For clusters running Memcached, this value must be between
	// 1 and 20.
	NumCacheNodes *int32
	// The ARN (Amazon Resource Name) of the snapshot.
	ARN *string
	// The user-supplied identifier of the source cluster.
	CacheClusterId *string
	// The Amazon Resource Name (ARN) for the topic used by the source cluster for
	// publishing notifications.
	TopicArn *string
	// The port number used by each cache nodes in the source cluster.
	Port *int32
	// The number of node groups (shards) in this snapshot. When restoring from a
	// snapshot, the number of node groups (shards) in the snapshot and in the restored
	// replication group must be the same.
	NumNodeGroups *int32
	// Indicates the status of automatic failover for the source Redis replication
	// group.
	AutomaticFailover AutomaticFailoverStatus
	// A description of the source replication group.
	ReplicationGroupDescription *string
	// The name of a snapshot. For an automatic snapshot, the name is system-generated.
	// For a manual snapshot, this is the user-provided name.
	SnapshotName *string
	// The name of the cache engine (memcached or redis) used by the source cluster.
	Engine *string
	// The unique identifier of the source replication group.
	ReplicationGroupId *string
}

type SnapshotAlreadyExistsFault struct {
	Message *string
}

type SnapshotFeatureNotSupportedFault struct {
	Message *string
}

type SnapshotNotFoundFault struct {
	Message *string
}

type SnapshotQuotaExceededFault struct {
	Message *string
}

type SourceType string

const (
	SourceTypeCacheCluster        SourceType = "cache-cluster"
	SourceTypeCacheParameterGroup SourceType = "cache-parameter-group"
	SourceTypeCacheSecurityGroup  SourceType = "cache-security-group"
	SourceTypeCacheSubnetGroup    SourceType = "cache-subnet-group"
	SourceTypeReplicationGroup    SourceType = "replication-group"
)

type Subnet struct {
	// The unique identifier for the subnet.
	SubnetIdentifier *string
	// The Availability Zone associated with the subnet.
	SubnetAvailabilityZone *AvailabilityZone
}

type SubnetInUse struct {
	Message *string
}

type Tag struct {
	// The key for the tag. May not be null.
	Key *string
	// The tag's value. May be null.
	Value *string
}

type TagNotFoundFault struct {
	Message *string
}

type TagQuotaPerResourceExceeded struct {
	Message *string
}

type TestFailoverNotAvailableFault struct {
	Message *string
}

type TimeRangeFilter struct {
	// The start time of the time range filter
	StartTime *time.Time
	// The end time of the time range filter
	EndTime *time.Time
}

type UnprocessedUpdateAction struct {
	// The replication group ID
	ReplicationGroupId *string
	// The unique ID of the service update
	ServiceUpdateName *string
	// The ID of the cache cluster
	CacheClusterId *string
	// The error message that describes the reason the request was not processed
	ErrorMessage *string
	// The error type for requests that are not processed
	ErrorType *string
}

type UpdateAction struct {
	// Reflects the nature of the service update
	ServiceUpdateType ServiceUpdateType
	// The date when the UpdateActionStatus was last modified
	UpdateActionStatusModifiedDate *time.Time
	// The severity of the service update
	ServiceUpdateSeverity ServiceUpdateSeverity
	// The unique ID of the service update
	ServiceUpdateName *string
	// The status of the service update on the cache node
	CacheNodeUpdateStatus []*CacheNodeUpdateStatus
	// The date that the service update is available to a replication group
	UpdateActionAvailableDate *time.Time
	// The progress of the service update on the replication group
	NodesUpdated *string
	// The status of the service update
	ServiceUpdateStatus ServiceUpdateStatus
	// The ID of the cache cluster
	CacheClusterId *string
	// The recommended date to apply the service update to ensure compliance. For
	// information on compliance, see Self-Service Security Updates for Compliance
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/elasticache-compliance.html#elasticache-compliance-self-service).
	ServiceUpdateRecommendedApplyByDate *time.Time
	// The status of the update action
	UpdateActionStatus UpdateActionStatus
	// The date the update is first available
	ServiceUpdateReleaseDate *time.Time
	// The ID of the replication group
	ReplicationGroupId *string
	// The estimated length of time for the update to complete
	EstimatedUpdateTime *string
	// If yes, all nodes in the replication group have been updated by the recommended
	// apply-by date. If no, at least one node in the replication group have not been
	// updated by the recommended apply-by date. If N/A, the replication group was
	// created after the recommended apply-by date.
	SlaMet SlaMet
	// The Elasticache engine to which the update applies. Either Redis or Memcached
	Engine *string
	// The status of the service update on the node group
	NodeGroupUpdateStatus []*NodeGroupUpdateStatus
}

type UpdateActionStatus string

const (
	UpdateActionStatusNot_applied      UpdateActionStatus = "not-applied"
	UpdateActionStatusWaiting_to_start UpdateActionStatus = "waiting-to-start"
	UpdateActionStatusIn_progress      UpdateActionStatus = "in-progress"
	UpdateActionStatusStopping         UpdateActionStatus = "stopping"
	UpdateActionStatusStopped          UpdateActionStatus = "stopped"
	UpdateActionStatusComplete         UpdateActionStatus = "complete"
	UpdateActionStatusScheduling       UpdateActionStatus = "scheduling"
	UpdateActionStatusScheduled        UpdateActionStatus = "scheduled"
	UpdateActionStatusNot_applicable   UpdateActionStatus = "not-applicable"
)