const ServiceAPIVersion = "2015-02-02"

const ServiceID = "ElastiCache"

type AddTagsToResourceInput struct {

	// The Amazon Resource Name (ARN) of the resource to which the tags are to be
	// added, for example arn:aws:elasticache:us-west-2:0123456789:cluster:myCluster or
	// arn:aws:elasticache:us-west-2:0123456789:snapshot:mySnapshot. ElastiCache
	// resources are cluster and snapshot. For more information about ARNs, see Amazon
	// Resource Names (ARNs) and AWS Service Namespaces
	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
	//
	// This member is required.
	ResourceName *string

	// A list of cost allocation tags to be added to this resource. A tag is a
	// key-value pair. A tag key must be accompanied by a tag value.
	//
	// This member is required.
	Tags []*types.Tag
}

type AddTagsToResourceOutput struct {

	// A list of cost allocation tags as key-value pairs.
	TagList []*types.Tag

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AuthorizeCacheSecurityGroupIngressInput struct {

	// The cache security group that allows network ingress.
	//
	// This member is required.
	CacheSecurityGroupName *string

	// The Amazon EC2 security group to be authorized for ingress to the cache security
	// group.
	//
	// This member is required.
	EC2SecurityGroupName *string

	// The AWS account number of the Amazon EC2 security group owner. Note that this is
	// not the same thing as an AWS access key ID - you must provide a valid AWS
	// account number for this parameter.
	//
	// This member is required.
	EC2SecurityGroupOwnerId *string
}

type AuthorizeCacheSecurityGroupIngressOutput struct {

	// Represents the output of one of the following operations:
	//
	//     *
	// AuthorizeCacheSecurityGroupIngress
	//
	//     * CreateCacheSecurityGroup
	//
	//     *
	// RevokeCacheSecurityGroupIngress
	CacheSecurityGroup *types.CacheSecurityGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchApplyUpdateActionInput struct {

	// The unique ID of the service update
	//
	// This member is required.
	ServiceUpdateName *string

	// The cache cluster IDs
	CacheClusterIds []*string

	// The replication group IDs
	ReplicationGroupIds []*string
}

type BatchApplyUpdateActionOutput struct {

	// Update actions that have been processed successfully
	ProcessedUpdateActions []*types.ProcessedUpdateAction

	// Update actions that haven't been processed successfully
	UnprocessedUpdateActions []*types.UnprocessedUpdateAction

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type BatchStopUpdateActionInput struct {

	// The unique ID of the service update
	//
	// This member is required.
	ServiceUpdateName *string

	// The cache cluster IDs
	CacheClusterIds []*string

	// The replication group IDs
	ReplicationGroupIds []*string
}

type BatchStopUpdateActionOutput struct {

	// Update actions that have been processed successfully
	ProcessedUpdateActions []*types.ProcessedUpdateAction

	// Update actions that haven't been processed successfully
	UnprocessedUpdateActions []*types.UnprocessedUpdateAction

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Client struct {
	// contains filtered or unexported fields
}

type CompleteMigrationInput struct {

	// The ID of the replication group to which data is being migrated.
	//
	// This member is required.
	ReplicationGroupId *string

	// Forces the migration to stop without ensuring that data is in sync. It is
	// recommended to use this option only to abort the migration and not recommended
	// when application wants to continue migration to ElastiCache.
	Force *bool
}

type CompleteMigrationOutput struct {

	// Contains all of the attributes of a specific Redis replication group.
	ReplicationGroup *types.ReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CopySnapshotInput struct {

	// The name of an existing snapshot from which to make a copy.
	//
	// This member is required.
	SourceSnapshotName *string

	// A name for the snapshot copy. ElastiCache does not permit overwriting a
	// snapshot, therefore this name must be unique within its context - ElastiCache or
	// an Amazon S3 bucket if exporting.
	//
	// This member is required.
	TargetSnapshotName *string

	// The ID of the KMS key used to encrypt the target snapshot.
	KmsKeyId *string

	// The Amazon S3 bucket to which the snapshot is exported. This parameter is used
	// only when exporting a snapshot for external access. When using this parameter to
	// export a snapshot, be sure Amazon ElastiCache has the needed permissions to this
	// S3 bucket. For more information, see Step 2: Grant ElastiCache Access to Your
	// Amazon S3 Bucket
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/backups-exporting.html#backups-exporting-grant-access)
	// in the Amazon ElastiCache User Guide. For more information, see Exporting a
	// Snapshot
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Snapshots.Exporting.html)
	// in the Amazon ElastiCache User Guide.
	TargetBucket *string
}

type CopySnapshotOutput struct {

	// Represents a copy of an entire Redis cluster as of the time when the snapshot
	// was taken.
	Snapshot *types.Snapshot

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateCacheClusterInput struct {

	// The node group (shard) identifier. This parameter is stored as a lowercase
	// string. Constraints:
	//
	//     * A name must contain from 1 to 50 alphanumeric
	// characters or hyphens.
	//
	//     * The first character must be a letter.
	//
	//     * A
	// name cannot end with a hyphen or contain two consecutive hyphens.
	//
	// This member is required.
	CacheClusterId *string

	// Specifies whether the nodes in this Memcached cluster are created in a single
	// Availability Zone or created across multiple Availability Zones in the cluster's
	// region. This parameter is only supported for Memcached clusters. If the AZMode
	// and PreferredAvailabilityZones are not specified, ElastiCache assumes single-az
	// mode.
	AZMode types.AZMode

	// Reserved parameter. The password used to access a password protected server.
	// Password constraints:
	//
	//     * Must be only printable ASCII characters.
	//
	//     *
	// Must be at least 16 characters and no more than 128 characters in length.
	//
	//     *
	// The only permitted printable special characters are !, &, #, $, ^, <, >, and -.
	// Other printable special characters cannot be used in the AUTH token.
	//
	// For more
	// information, see AUTH password (http://redis.io/commands/AUTH) at
	// http://redis.io/commands/AUTH.
	AuthToken *string

	// This parameter is currently disabled.
	AutoMinorVersionUpgrade *bool

	// The compute and memory capacity of the nodes in the node group (shard). 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: M5 node types: cache.m5.large,
	// cache.m5.xlarge, cache.m5.2xlarge, cache.m5.4xlarge, cache.m5.12xlarge,
	// cache.m5.24xlarge M4 node types: cache.m4.large, cache.m4.xlarge,
	// cache.m4.2xlarge, cache.m4.4xlarge, cache.m4.10xlarge T3 node types:
	// cache.t3.micro, cache.t3.small, cache.t3.medium T2 node types: cache.t2.micro,
	// cache.t2.small, cache.t2.medium
	//
	//         * Previous generation: (not
	// recommended) T1 node types: cache.t1.micro M1 node types: cache.m1.small,
	// cache.m1.medium, cache.m1.large, cache.m1.xlarge M3 node types: cache.m3.medium,
	// cache.m3.large, cache.m3.xlarge, cache.m3.2xlarge
	//
	//     * Compute optimized:
	//
	//
	// * Previous generation: (not recommended) C1 node types: cache.c1.xlarge
	//
	//     *
	// Memory optimized:
	//
	//         * Current generation: R5 node types: cache.r5.large,
	// cache.r5.xlarge, cache.r5.2xlarge, cache.r5.4xlarge, cache.r5.12xlarge,
	// cache.r5.24xlarge R4 node types: cache.r4.large, cache.r4.xlarge,
	// cache.r4.2xlarge, cache.r4.4xlarge, cache.r4.8xlarge, cache.r4.16xlarge
	//
	//
	// * Previous generation: (not recommended) M2 node types: cache.m2.xlarge,
	// cache.m2.2xlarge, cache.m2.4xlarge R3 node types: cache.r3.large,
	// cache.r3.xlarge, cache.r3.2xlarge,
	//
	//         cache.r3.4xlarge,
	// cache.r3.8xlarge
	//
	// Additional node type info
	//
	//     * All current generation
	// instance types are created in Amazon VPC by default.
	//
	//     * Redis append-only
	// files (AOF) are not supported for T1 or T2 instances.
	//
	//     * Redis Multi-AZ with
	// automatic failover is not supported on T1 instances.
	//
	//     * Redis configuration
	// variables appendonly and appendfsync are not supported on Redis version 2.8.22
	// and later.
	CacheNodeType *string

	// The name of the parameter group to associate with this cluster. If this argument
	// is omitted, the default parameter group for the specified engine is used. You
	// cannot use any parameter group which has cluster-enabled='yes' when creating a
	// cluster.
	CacheParameterGroupName *string

	// A list of security group names to associate with this cluster. Use this
	// parameter only when you are creating a cluster outside of an Amazon Virtual
	// Private Cloud (Amazon VPC).
	CacheSecurityGroupNames []*string

	// The name of the subnet group to be used for the cluster. Use this parameter only
	// when you are creating a cluster in an Amazon Virtual Private Cloud (Amazon VPC).
	// If you're going to launch your cluster in an Amazon VPC, you need to create a
	// subnet group before you start creating a cluster. For more information, see
	// Subnets and Subnet Groups
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/SubnetGroups.html).
	CacheSubnetGroupName *string

	// The name of the cache engine to be used for this cluster. Valid values for this
	// parameter are: memcached | redis
	Engine *string

	// The version number of the cache engine to be used for this cluster. To view the
	// supported cache engine versions, use the DescribeCacheEngineVersions operation.
	// Important: You can upgrade to a newer engine version (see Selecting a Cache
	// Engine and Version
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/SelectEngine.html#VersionManagement)),
	// but you cannot downgrade to an earlier engine version. If you want to use an
	// earlier engine version, you must delete the existing cluster or replication
	// group and create it anew with the earlier engine version.
	EngineVersion *string

	// The Amazon Resource Name (ARN) of the Amazon Simple Notification Service (SNS)
	// topic to which notifications are sent. The Amazon SNS topic owner must be the
	// same as the cluster owner.
	NotificationTopicArn *string

	// The initial number of cache nodes that the cluster has. For clusters running
	// Redis, this value must be 1. For clusters running Memcached, this value must be
	// between 1 and 20. If you need more than 20 nodes for your Memcached cluster,
	// please fill out the ElastiCache Limit Increase Request form at
	// http://aws.amazon.com/contact-us/elasticache-node-limit-request/
	// (http://aws.amazon.com/contact-us/elasticache-node-limit-request/).
	NumCacheNodes *int32

	// The port number on which each of the cache nodes accepts connections.
	Port *int32

	// The EC2 Availability Zone in which the cluster is created. All nodes belonging
	// to this cluster are placed in the preferred Availability Zone. If you want to
	// create your nodes across multiple Availability Zones, use
	// PreferredAvailabilityZones. Default: System chosen Availability Zone.
	PreferredAvailabilityZone *string

	// A list of the Availability Zones in which cache nodes are created. The order of
	// the zones in the list is not important. This option is only supported on
	// Memcached. If you are creating your cluster in an Amazon VPC (recommended) you
	// can only locate nodes in Availability Zones that are associated with the subnets
	// in the selected subnet group. The number of Availability Zones listed must equal
	// the value of NumCacheNodes. If you want all the nodes in the same Availability
	// Zone, use PreferredAvailabilityZone instead, or repeat the Availability Zone
	// multiple times in the list. Default: System chosen Availability Zones.
	PreferredAvailabilityZones []*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: 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 ID of the replication group to which this cluster should belong. If this
	// parameter is specified, the cluster is added to the specified replication group
	// as a read replica; otherwise, the cluster is a standalone primary that is not
	// part of any replication group. If the specified replication group is Multi-AZ
	// enabled and the Availability Zone is not specified, the cluster is created in
	// Availability Zones that provide the best spread of read replicas across
	// Availability Zones. This parameter is only valid if the Engine parameter is
	// redis.
	ReplicationGroupId *string

	// One or more VPC security groups associated with the cluster. Use this parameter
	// only when you are creating a cluster in an Amazon Virtual Private Cloud (Amazon
	// VPC).
	SecurityGroupIds []*string

	// A single-element string list containing an Amazon Resource Name (ARN) that
	// uniquely identifies a Redis RDB snapshot file stored in Amazon S3. The snapshot
	// file is used to populate the node group (shard). The Amazon S3 object name in
	// the ARN cannot contain any commas. This parameter is only valid if the Engine
	// parameter is redis. Example of an Amazon S3 ARN:
	// arn:aws:s3:::my_bucket/snapshot1.rdb
	SnapshotArns []*string

	// The name of a Redis snapshot from which to restore data into the new node group
	// (shard). The snapshot status changes to restoring while the new node group
	// (shard) is being created. This parameter is only valid if the Engine parameter
	// is redis.
	SnapshotName *string

	// The number of days for which ElastiCache retains automatic snapshots before
	// deleting them. For example, if you set SnapshotRetentionLimit to 5, a snapshot
	// taken today is retained for 5 days before being deleted. This parameter is only
	// valid if the Engine parameter is redis. Default: 0 (i.e., automatic backups are
	// disabled for this cache cluster).
	SnapshotRetentionLimit *int32

	// 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 list of cost allocation tags to be added to this resource.
	Tags []*types.Tag
}

type CreateCacheClusterOutput struct {

	// Contains all of the attributes of a specific cluster.
	CacheCluster *types.CacheCluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateCacheParameterGroupInput struct {

	// The name of the cache parameter group family that the cache parameter group can
	// be used with. Valid values are: memcached1.4 | memcached1.5 | redis2.6 |
	// redis2.8 | redis3.2 | redis4.0 | redis5.0 |
	//
	// This member is required.
	CacheParameterGroupFamily *string

	// A user-specified name for the cache parameter group.
	//
	// This member is required.
	CacheParameterGroupName *string

	// A user-specified description for the cache parameter group.
	//
	// This member is required.
	Description *string
}

type CreateCacheParameterGroupOutput struct {

	// Represents the output of a CreateCacheParameterGroup operation.
	CacheParameterGroup *types.CacheParameterGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateCacheSecurityGroupInput struct {

	// A name for the cache security group. This value is stored as a lowercase string.
	// Constraints: Must contain no more than 255 alphanumeric characters. Cannot be
	// the word "Default". Example: mysecuritygroup
	//
	// This member is required.
	CacheSecurityGroupName *string

	// A description for the cache security group.
	//
	// This member is required.
	Description *string
}

type CreateCacheSecurityGroupOutput struct {

	// Represents the output of one of the following operations:
	//
	//     *
	// AuthorizeCacheSecurityGroupIngress
	//
	//     * CreateCacheSecurityGroup
	//
	//     *
	// RevokeCacheSecurityGroupIngress
	CacheSecurityGroup *types.CacheSecurityGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateCacheSubnetGroupInput struct {

	// A description for the cache subnet group.
	//
	// This member is required.
	CacheSubnetGroupDescription *string

	// A name for the cache subnet group. This value is stored as a lowercase string.
	// Constraints: Must contain no more than 255 alphanumeric characters or hyphens.
	// Example: mysubnetgroup
	//
	// This member is required.
	CacheSubnetGroupName *string

	// A list of VPC subnet IDs for the cache subnet group.
	//
	// This member is required.
	SubnetIds []*string
}

type CreateCacheSubnetGroupOutput struct {

	// Represents the output of one of the following operations:
	//
	//     *
	// CreateCacheSubnetGroup
	//
	//     * ModifyCacheSubnetGroup
	CacheSubnetGroup *types.CacheSubnetGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateGlobalReplicationGroupInput struct {

	// The suffix name of a Global Datastore. The suffix guarantees uniqueness of the
	// Global Datastore name across multiple regions.
	//
	// This member is required.
	GlobalReplicationGroupIdSuffix *string

	// The name of the primary cluster that accepts writes and will replicate updates
	// to the secondary cluster.
	//
	// This member is required.
	PrimaryReplicationGroupId *string

	// Provides details of the Global Datastore
	GlobalReplicationGroupDescription *string
}

type CreateGlobalReplicationGroupOutput struct {

	// Consists of a primary cluster that accepts writes and an associated secondary
	// cluster that resides in a different AWS region. The secondary cluster accepts
	// only reads. The primary cluster automatically replicates updates to the
	// secondary cluster.
	//
	//     * The GlobalReplicationGroupIdSuffix represents the name
	// of the Global Datastore, which is what you use to associate a secondary cluster.
	GlobalReplicationGroup *types.GlobalReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateReplicationGroupInput struct {

	// A user-created description for the replication group.
	//
	// This member is required.
	ReplicationGroupDescription *string

	// The replication group identifier. This parameter is stored as a lowercase
	// string. Constraints:
	//
	//     * A name must contain from 1 to 40 alphanumeric
	// characters or hyphens.
	//
	//     * The first character must be a letter.
	//
	//     * A
	// name cannot end with a hyphen or contain two consecutive hyphens.
	//
	// This member is required.
	ReplicationGroupId *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. Default: false
	AtRestEncryptionEnabled *bool

	// Reserved parameter. The password used to access a password protected server.
	// AuthToken can be specified only on replication groups where
	// TransitEncryptionEnabled is true. For HIPAA compliance, you must specify
	// TransitEncryptionEnabled as true, an AuthToken, and a CacheSubnetGroup. Password
	// constraints:
	//
	//     * Must be only printable ASCII characters.
	//
	//     * Must be at
	// least 16 characters and no more than 128 characters in length.
	//
	//     * The only
	// permitted printable special characters are !, &, #, $, ^, <, >, and -. Other
	// printable special characters cannot be used in the AUTH token.
	//
	// For more
	// information, see AUTH password (http://redis.io/commands/AUTH) at
	// http://redis.io/commands/AUTH.
	AuthToken *string

	// This parameter is currently disabled.
	AutoMinorVersionUpgrade *bool

	// Specifies whether a read-only replica is automatically promoted to read/write
	// primary if the existing primary fails. AutomaticFailoverEnabled must be enabled
	// for Redis (cluster mode enabled) replication groups. Default: false
	AutomaticFailoverEnabled *bool

	// The compute and memory capacity of the nodes in the node group (shard). 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: M5 node types: cache.m5.large,
	// cache.m5.xlarge, cache.m5.2xlarge, cache.m5.4xlarge, cache.m5.12xlarge,
	// cache.m5.24xlarge M4 node types: cache.m4.large, cache.m4.xlarge,
	// cache.m4.2xlarge, cache.m4.4xlarge, cache.m4.10xlarge T3 node types:
	// cache.t3.micro, cache.t3.small, cache.t3.medium T2 node types: cache.t2.micro,
	// cache.t2.small, cache.t2.medium
	//
	//         * Previous generation: (not
	// recommended) T1 node types: cache.t1.micro M1 node types: cache.m1.small,
	// cache.m1.medium, cache.m1.large, cache.m1.xlarge M3 node types: cache.m3.medium,
	// cache.m3.large, cache.m3.xlarge, cache.m3.2xlarge
	//
	//     * Compute optimized:
	//
	//
	// * Previous generation: (not recommended) C1 node types: cache.c1.xlarge
	//
	//     *
	// Memory optimized:
	//
	//         * Current generation: R5 node types: cache.r5.large,
	// cache.r5.xlarge, cache.r5.2xlarge, cache.r5.4xlarge, cache.r5.12xlarge,
	// cache.r5.24xlarge R4 node types: cache.r4.large, cache.r4.xlarge,
	// cache.r4.2xlarge, cache.r4.4xlarge, cache.r4.8xlarge, cache.r4.16xlarge
	//
	//
	// * Previous generation: (not recommended) M2 node types: cache.m2.xlarge,
	// cache.m2.2xlarge, cache.m2.4xlarge R3 node types: cache.r3.large,
	// cache.r3.xlarge, cache.r3.2xlarge,
	//
	//         cache.r3.4xlarge,
	// cache.r3.8xlarge
	//
	// Additional node type info
	//
	//     * All current generation
	// instance types are created in Amazon VPC by default.
	//
	//     * Redis append-only
	// files (AOF) are not supported for T1 or T2 instances.
	//
	//     * Redis Multi-AZ with
	// automatic failover is not supported on T1 instances.
	//
	//     * Redis configuration
	// variables appendonly and appendfsync are not supported on Redis version 2.8.22
	// and later.
	CacheNodeType *string

	// The name of the parameter group to associate with this replication group. If
	// this argument is omitted, the default cache parameter group for the specified
	// engine is used. If you are restoring to an engine version that is different than
	// the original, you must specify the default version of that version. For example,
	// CacheParameterGroupName=default.redis4.0. If you are running Redis version 3.2.4
	// or later, only one node group (shard), and want to use a default parameter
	// group, we recommend that you specify the parameter group by name.
	//
	//     * To
	// create a Redis (cluster mode disabled) replication group, use
	// CacheParameterGroupName=default.redis3.2.
	//
	//     * To create a Redis (cluster mode
	// enabled) replication group, use
	// CacheParameterGroupName=default.redis3.2.cluster.on.
	CacheParameterGroupName *string

	// A list of cache security group names to associate with this replication group.
	CacheSecurityGroupNames []*string

	// The name of the cache subnet group to be used for the replication group. If
	// you're going to launch your cluster in an Amazon VPC, you need to create a
	// subnet group before you start creating a cluster. For more information, see
	// Subnets and Subnet Groups
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/SubnetGroups.html).
	CacheSubnetGroupName *string

	// The name of the cache engine to be used for the clusters in this replication
	// group.
	Engine *string

	// The version number of the cache engine to be used for the clusters in this
	// replication group. To view the supported cache engine versions, use the
	// DescribeCacheEngineVersions operation. Important: You can upgrade to a newer
	// engine version (see Selecting a Cache Engine and Version
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/SelectEngine.html#VersionManagement))
	// in the ElastiCache User Guide, but you cannot downgrade to an earlier engine
	// version. If you want to use an earlier engine version, you must delete the
	// existing cluster or replication group and create it anew with the earlier engine
	// version.
	EngineVersion *string

	// The name of the Global Datastore
	GlobalReplicationGroupId *string

	// The ID of the KMS key used to encrypt the disk in the cluster.
	KmsKeyId *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).
	MultiAZEnabled *bool

	// A list of node group (shard) configuration options. Each node group (shard)
	// configuration has the following members: PrimaryAvailabilityZone,
	// ReplicaAvailabilityZones, ReplicaCount, and Slots. If you're creating a Redis
	// (cluster mode disabled) or a Redis (cluster mode enabled) replication group, you
	// can use this parameter to individually configure each node group (shard), or you
	// can omit this parameter. However, it is required when seeding a Redis (cluster
	// mode enabled) cluster from a S3 rdb file. You must configure each node group
	// (shard) using this parameter because you must specify the slots for each node
	// group.
	NodeGroupConfiguration []*types.NodeGroupConfiguration

	// The Amazon Resource Name (ARN) of the Amazon Simple Notification Service (SNS)
	// topic to which notifications are sent. The Amazon SNS topic owner must be the
	// same as the cluster owner.
	NotificationTopicArn *string

	// The number of clusters this replication group initially has. This parameter is
	// not used if there is more than one node group (shard). You should use
	// ReplicasPerNodeGroup instead. If AutomaticFailoverEnabled is true, the value of
	// this parameter must be at least 2. If AutomaticFailoverEnabled is false you can
	// omit this parameter (it will default to 1), or you can explicitly set it to a
	// value between 2 and 6. The maximum permitted value for NumCacheClusters is 6 (1
	// primary plus 5 replicas).
	NumCacheClusters *int32

	// An optional parameter that specifies the number of node groups (shards) for this
	// Redis (cluster mode enabled) replication group. For Redis (cluster mode
	// disabled) either omit this parameter or set it to 1. Default: 1
	NumNodeGroups *int32

	// The port number on which each member of the replication group accepts
	// connections.
	Port *int32

	// A list of EC2 Availability Zones in which the replication group's clusters are
	// created. The order of the Availability Zones in the list is the order in which
	// clusters are allocated. The primary cluster is created in the first AZ in the
	// list. This parameter is not used if there is more than one node group (shard).
	// You should use NodeGroupConfiguration instead. If you are creating your
	// replication group in an Amazon VPC (recommended), you can only locate clusters
	// in Availability Zones associated with the subnets in the selected subnet group.
	// The number of Availability Zones listed must equal the value of
	// NumCacheClusters. Default: system chosen Availability Zones.
	PreferredCacheClusterAZs []*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: 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 identifier of the cluster that serves as the primary for this replication
	// group. This cluster must already exist and have a status of available. This
	// parameter is not required if NumCacheClusters, NumNodeGroups, or
	// ReplicasPerNodeGroup is specified.
	PrimaryClusterId *string

	// An optional parameter that specifies the number of replica nodes in each node
	// group (shard). Valid values are 0 to 5.
	ReplicasPerNodeGroup *int32

	// One or more Amazon VPC security groups associated with this replication group.
	// Use this parameter only when you are creating a replication group in an Amazon
	// Virtual Private Cloud (Amazon VPC).
	SecurityGroupIds []*string

	// A list of Amazon Resource Names (ARN) that uniquely identify the Redis RDB
	// snapshot files stored in Amazon S3. The snapshot files are used to populate the
	// new replication group. The Amazon S3 object name in the ARN cannot contain any
	// commas. The new replication group will have the number of node groups (console:
	// shards) specified by the parameter NumNodeGroups or the number of node groups
	// configured by NodeGroupConfiguration regardless of the number of ARNs specified
	// here. Example of an Amazon S3 ARN: arn:aws:s3:::my_bucket/snapshot1.rdb
	SnapshotArns []*string

	// The name of a snapshot from which to restore data into the new replication
	// group. The snapshot status changes to restoring while the new replication group
	// is being created.
	SnapshotName *string

	// The number of days for which ElastiCache retains automatic 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. Default: 0
	// (i.e., automatic backups are disabled for this cluster).
	SnapshotRetentionLimit *int32

	// 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.
	SnapshotWindow *string

	// A list of cost allocation tags to be added to this resource. Tags are
	// comma-separated key,value pairs (e.g. Key=myKey, Value=myKeyValue. You can
	// include multiple tags as shown following: Key=myKey, Value=myKeyValue
	// Key=mySecondKey, Value=mySecondKeyValue.
	Tags []*types.Tag

	// 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. This parameter is valid only if the Engine parameter
	// is redis, the EngineVersion parameter is 3.2.6, 4.x or later, and the cluster is
	// being created in an Amazon VPC. If you enable in-transit encryption, you must
	// also specify a value for CacheSubnetGroup. Required: Only available when
	// creating a replication group in an Amazon VPC using redis version 3.2.6, 4.x or
	// later. Default: false For HIPAA compliance, you must specify
	// TransitEncryptionEnabled as true, an AuthToken, and a CacheSubnetGroup.
	TransitEncryptionEnabled *bool
}

type CreateReplicationGroupOutput struct {

	// Contains all of the attributes of a specific Redis replication group.
	ReplicationGroup *types.ReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateSnapshotInput struct {

	// A name for the snapshot being created.
	//
	// This member is required.
	SnapshotName *string

	// The identifier of an existing cluster. The snapshot is created from this
	// cluster.
	CacheClusterId *string

	// The ID of the KMS key used to encrypt the snapshot.
	KmsKeyId *string

	// The identifier of an existing replication group. The snapshot is created from
	// this replication group.
	ReplicationGroupId *string
}

type CreateSnapshotOutput struct {

	// Represents a copy of an entire Redis cluster as of the time when the snapshot
	// was taken.
	Snapshot *types.Snapshot

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DecreaseNodeGroupsInGlobalReplicationGroupInput struct {

	// Indicates that the shard reconfiguration process begins immediately. At present,
	// the only permitted value for this parameter is true.
	//
	// This member is required.
	ApplyImmediately *bool

	// The name of the Global Datastore
	//
	// This member is required.
	GlobalReplicationGroupId *string

	// The number of node groups (shards) that results from the modification of the
	// shard configuration
	//
	// This member is required.
	NodeGroupCount *int32

	// If the value of NodeGroupCount is less than the current number of node groups
	// (shards), then either NodeGroupsToRemove or NodeGroupsToRetain is required.
	// NodeGroupsToRemove is a list of NodeGroupIds to remove from the cluster.
	// ElastiCache for Redis will attempt to remove all node groups listed by
	// NodeGroupsToRemove from the cluster.
	GlobalNodeGroupsToRemove []*string

	// If the value of NodeGroupCount is less than the current number of node groups
	// (shards), then either NodeGroupsToRemove or NodeGroupsToRetain is required.
	// NodeGroupsToRemove is a list of NodeGroupIds to remove from the cluster.
	// ElastiCache for Redis will attempt to remove all node groups listed by
	// NodeGroupsToRemove from the cluster.
	GlobalNodeGroupsToRetain []*string
}

type DecreaseNodeGroupsInGlobalReplicationGroupOutput struct {

	// Consists of a primary cluster that accepts writes and an associated secondary
	// cluster that resides in a different AWS region. The secondary cluster accepts
	// only reads. The primary cluster automatically replicates updates to the
	// secondary cluster.
	//
	//     * The GlobalReplicationGroupIdSuffix represents the name
	// of the Global Datastore, which is what you use to associate a secondary cluster.
	GlobalReplicationGroup *types.GlobalReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DecreaseReplicaCountInput struct {

	// If True, the number of replica nodes is decreased immediately.
	// ApplyImmediately=False is not currently supported.
	//
	// This member is required.
	ApplyImmediately *bool

	// The id of the replication group from which you want to remove replica nodes.
	//
	// This member is required.
	ReplicationGroupId *string

	// The number of read replica nodes you want at the completion of this operation.
	// For Redis (cluster mode disabled) replication groups, this is the number of
	// replica nodes in the replication group. For Redis (cluster mode enabled)
	// replication groups, this is the number of replica nodes in each of the
	// replication group's node groups. The minimum number of replicas in a shard or
	// replication group is:
	//
	//     * Redis (cluster mode disabled)
	//
	//         * If
	// Multi-AZ is enabled: 1
	//
	//         * If Multi-AZ is not enabled: 0
	//
	//     * Redis
	// (cluster mode enabled): 0 (though you will not be able to failover to a replica
	// if your primary node fails)
	NewReplicaCount *int32

	// A list of ConfigureShard objects that can be used to configure each shard in a
	// Redis (cluster mode enabled) replication group. The ConfigureShard has three
	// members: NewReplicaCount, NodeGroupId, and PreferredAvailabilityZones.
	ReplicaConfiguration []*types.ConfigureShard

	// A list of the node ids to remove from the replication group or node group
	// (shard).
	ReplicasToRemove []*string
}

type DecreaseReplicaCountOutput struct {

	// Contains all of the attributes of a specific Redis replication group.
	ReplicationGroup *types.ReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteCacheClusterInput struct {

	// The cluster identifier for the cluster to be deleted. This parameter is not case
	// sensitive.
	//
	// This member is required.
	CacheClusterId *string

	// The user-supplied name of a final cluster snapshot. This is the unique name that
	// identifies the snapshot. ElastiCache creates the snapshot, and then deletes the
	// cluster immediately afterward.
	FinalSnapshotIdentifier *string
}

type DeleteCacheClusterOutput struct {

	// Contains all of the attributes of a specific cluster.
	CacheCluster *types.CacheCluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteCacheParameterGroupInput struct {

	// The name of the cache parameter group to delete. The specified cache security
	// group must not be associated with any clusters.
	//
	// This member is required.
	CacheParameterGroupName *string
}

type DeleteCacheParameterGroupOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteCacheSecurityGroupInput struct {

	// The name of the cache security group to delete. You cannot delete the default
	// security group.
	//
	// This member is required.
	CacheSecurityGroupName *string
}

type DeleteCacheSecurityGroupOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteCacheSubnetGroupInput struct {

	// The name of the cache subnet group to delete. Constraints: Must contain no more
	// than 255 alphanumeric characters or hyphens.
	//
	// This member is required.
	CacheSubnetGroupName *string
}

type DeleteCacheSubnetGroupOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteGlobalReplicationGroupInput struct {

	// The name of the Global Datastore
	//
	// This member is required.
	GlobalReplicationGroupId *string

	// The primary replication group is retained as a standalone replication group.
	//
	// This member is required.
	RetainPrimaryReplicationGroup *bool
}

type DeleteGlobalReplicationGroupOutput struct {

	// Consists of a primary cluster that accepts writes and an associated secondary
	// cluster that resides in a different AWS region. The secondary cluster accepts
	// only reads. The primary cluster automatically replicates updates to the
	// secondary cluster.
	//
	//     * The GlobalReplicationGroupIdSuffix represents the name
	// of the Global Datastore, which is what you use to associate a secondary cluster.
	GlobalReplicationGroup *types.GlobalReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteReplicationGroupInput struct {

	// The identifier for the cluster to be deleted. This parameter is not case
	// sensitive.
	//
	// This member is required.
	ReplicationGroupId *string

	// The name of a final node group (shard) snapshot. ElastiCache creates the
	// snapshot from the primary node in the cluster, rather than one of the replicas;
	// this is to ensure that it captures the freshest data. After the final snapshot
	// is taken, the replication group is immediately deleted.
	FinalSnapshotIdentifier *string

	// If set to true, all of the read replicas are deleted, but the primary node is
	// retained.
	RetainPrimaryCluster *bool
}

type DeleteReplicationGroupOutput struct {

	// Contains all of the attributes of a specific Redis replication group.
	ReplicationGroup *types.ReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteSnapshotInput struct {

	// The name of the snapshot to be deleted.
	//
	// This member is required.
	SnapshotName *string
}

type DeleteSnapshotOutput struct {

	// Represents a copy of an entire Redis cluster as of the time when the snapshot
	// was taken.
	Snapshot *types.Snapshot

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeCacheClustersInput struct {

	// The user-supplied cluster identifier. If this parameter is specified, only
	// information about that specific cluster is returned. This parameter isn't case
	// sensitive.
	CacheClusterId *string

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a marker is included in the response so
	// that the remaining results can be retrieved. Default: 100 Constraints: minimum
	// 20; maximum 100.
	MaxRecords *int32

	// An optional flag that can be included in the DescribeCacheCluster request to
	// show only nodes (API/CLI: clusters) that are not members of a replication group.
	// In practice, this mean Memcached and single node Redis clusters.
	ShowCacheClustersNotInReplicationGroups *bool

	// An optional flag that can be included in the DescribeCacheCluster request to
	// retrieve information about the individual cache nodes.
	ShowCacheNodeInfo *bool
}

type DescribeCacheClustersOutput struct {

	// A list of clusters. Each item in the list contains detailed information about
	// one cluster.
	CacheClusters []*types.CacheCluster

	// Provides an identifier to allow retrieval of paginated results.
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeCacheEngineVersionsInput struct {

	// The name of a specific cache parameter group family to return details for. Valid
	// values are: memcached1.4 | memcached1.5 | redis2.6 | redis2.8 | redis3.2 |
	// redis4.0 | redis5.0 | Constraints:
	//
	//     * Must be 1 to 255 alphanumeric
	// characters
	//
	//     * First character must be a letter
	//
	//     * Cannot end with a
	// hyphen or contain two consecutive hyphens
	CacheParameterGroupFamily *string

	// If true, specifies that only the default version of the specified engine or
	// engine and major version combination is to be returned.
	DefaultOnly *bool

	// The cache engine to return. Valid values: memcached | redis
	Engine *string

	// The cache engine version to return. Example: 1.4.14
	EngineVersion *string

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a marker is included in the response so
	// that the remaining results can be retrieved. Default: 100 Constraints: minimum
	// 20; maximum 100.
	MaxRecords *int32
}

type DescribeCacheEngineVersionsOutput struct {

	// A list of cache engine version details. Each element in the list contains
	// detailed information about one cache engine version.
	CacheEngineVersions []*types.CacheEngineVersion

	// Provides an identifier to allow retrieval of paginated results.
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeCacheParameterGroupsInput struct {

	// The name of a specific cache parameter group to return details for.
	CacheParameterGroupName *string

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a marker is included in the response so
	// that the remaining results can be retrieved. Default: 100 Constraints: minimum
	// 20; maximum 100.
	MaxRecords *int32
}

type DescribeCacheParameterGroupsOutput struct {

	// A list of cache parameter groups. Each element in the list contains detailed
	// information about one cache parameter group.
	CacheParameterGroups []*types.CacheParameterGroup

	// Provides an identifier to allow retrieval of paginated results.
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeCacheParametersInput struct {

	// The name of a specific cache parameter group to return details for.
	//
	// This member is required.
	CacheParameterGroupName *string

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a marker is included in the response so
	// that the remaining results can be retrieved. Default: 100 Constraints: minimum
	// 20; maximum 100.
	MaxRecords *int32

	// The parameter types to return. Valid values: user | system | engine-default
	Source *string
}

type DescribeCacheParametersOutput struct {

	// A list of parameters specific to a particular cache node type. Each element in
	// the list contains detailed information about one parameter.
	CacheNodeTypeSpecificParameters []*types.CacheNodeTypeSpecificParameter

	// Provides an identifier to allow retrieval of paginated results.
	Marker *string

	// A list of Parameter instances.
	Parameters []*types.Parameter

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeCacheSecurityGroupsInput struct {

	// The name of the cache security group to return details for.
	CacheSecurityGroupName *string

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a marker is included in the response so
	// that the remaining results can be retrieved. Default: 100 Constraints: minimum
	// 20; maximum 100.
	MaxRecords *int32
}

type DescribeCacheSecurityGroupsOutput struct {

	// A list of cache security groups. Each element in the list contains detailed
	// information about one group.
	CacheSecurityGroups []*types.CacheSecurityGroup

	// Provides an identifier to allow retrieval of paginated results.
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeCacheSubnetGroupsInput struct {

	// The name of the cache subnet group to return details for.
	CacheSubnetGroupName *string

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a marker is included in the response so
	// that the remaining results can be retrieved. Default: 100 Constraints: minimum
	// 20; maximum 100.
	MaxRecords *int32
}

type DescribeCacheSubnetGroupsOutput struct {

	// A list of cache subnet groups. Each element in the list contains detailed
	// information about one group.
	CacheSubnetGroups []*types.CacheSubnetGroup

	// Provides an identifier to allow retrieval of paginated results.
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeEngineDefaultParametersInput struct {

	// The name of the cache parameter group family. Valid values are: memcached1.4 |
	// memcached1.5 | redis2.6 | redis2.8 | redis3.2 | redis4.0 | redis5.0 |
	//
	// This member is required.
	CacheParameterGroupFamily *string

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a marker is included in the response so
	// that the remaining results can be retrieved. Default: 100 Constraints: minimum
	// 20; maximum 100.
	MaxRecords *int32
}

type DescribeEngineDefaultParametersOutput struct {

	// Represents the output of a DescribeEngineDefaultParameters operation.
	EngineDefaults *types.EngineDefaults

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeEventsInput struct {

	// The number of minutes worth of events to retrieve.
	Duration *int32

	// The end of the time interval for which to retrieve events, specified in ISO 8601
	// format. Example: 2017-03-30T07:03:49.555Z
	EndTime *time.Time

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a marker is included in the response so
	// that the remaining results can be retrieved. Default: 100 Constraints: minimum
	// 20; maximum 100.
	MaxRecords *int32

	// The identifier of the event source for which events are returned. If not
	// specified, all sources are included in the response.
	SourceIdentifier *string

	// The event source to retrieve events for. If no value is specified, all events
	// are returned.
	SourceType types.SourceType

	// The beginning of the time interval to retrieve events for, specified in ISO 8601
	// format. Example: 2017-03-30T07:03:49.555Z
	StartTime *time.Time
}

type DescribeEventsOutput struct {

	// A list of events. Each element in the list contains detailed information about
	// one event.
	Events []*types.Event

	// Provides an identifier to allow retrieval of paginated results.
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeGlobalReplicationGroupsInput struct {

	// The name of the Global Datastore
	GlobalReplicationGroupId *string

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a marker is included in the response so
	// that the remaining results can be retrieved.
	MaxRecords *int32

	// Returns the list of members that comprise the Global Datastore.
	ShowMemberInfo *bool
}

type DescribeGlobalReplicationGroupsOutput struct {

	// Indicates the slot configuration and global identifier for each slice group.
	GlobalReplicationGroups []*types.GlobalReplicationGroup

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords. >
	Marker *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeReplicationGroupsInput struct {

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a marker is included in the response so
	// that the remaining results can be retrieved. Default: 100 Constraints: minimum
	// 20; maximum 100.
	MaxRecords *int32

	// The identifier for the replication group to be described. This parameter is not
	// case sensitive. If you do not specify this parameter, information about all
	// replication groups is returned.
	ReplicationGroupId *string
}

type DescribeReplicationGroupsOutput struct {

	// Provides an identifier to allow retrieval of paginated results.
	Marker *string

	// A list of replication groups. Each item in the list contains detailed
	// information about one replication group.
	ReplicationGroups []*types.ReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeReservedCacheNodesInput struct {

	// The cache node type filter value. Use this parameter to show only those
	// reservations matching the specified cache node type. 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: M5 node types: cache.m5.large, cache.m5.xlarge,
	// cache.m5.2xlarge, cache.m5.4xlarge, cache.m5.12xlarge, cache.m5.24xlarge M4 node
	// types: cache.m4.large, cache.m4.xlarge, cache.m4.2xlarge, cache.m4.4xlarge,
	// cache.m4.10xlarge T3 node types: cache.t3.micro, cache.t3.small, cache.t3.medium
	// T2 node types: cache.t2.micro, cache.t2.small, cache.t2.medium
	//
	//         *
	// Previous generation: (not recommended) T1 node types: cache.t1.micro M1 node
	// types: cache.m1.small, cache.m1.medium, cache.m1.large, cache.m1.xlarge M3 node
	// types: cache.m3.medium, cache.m3.large, cache.m3.xlarge, cache.m3.2xlarge
	//
	//     *
	// Compute optimized:
	//
	//         * Previous generation: (not recommended) C1 node
	// types: cache.c1.xlarge
	//
	//     * Memory optimized:
	//
	//         * Current generation:
	// R5 node types: cache.r5.large, cache.r5.xlarge, cache.r5.2xlarge,
	// cache.r5.4xlarge, cache.r5.12xlarge, cache.r5.24xlarge R4 node types:
	// cache.r4.large, cache.r4.xlarge, cache.r4.2xlarge, cache.r4.4xlarge,
	// cache.r4.8xlarge, cache.r4.16xlarge
	//
	//         * Previous generation: (not
	// recommended) M2 node types: cache.m2.xlarge, cache.m2.2xlarge, cache.m2.4xlarge
	// R3 node types: cache.r3.large, cache.r3.xlarge, cache.r3.2xlarge,
	//
	//
	// cache.r3.4xlarge, cache.r3.8xlarge
	//
	// Additional node type info
	//
	//     * All current
	// generation instance types are created in Amazon VPC by default.
	//
	//     * Redis
	// append-only files (AOF) are not supported for T1 or T2 instances.
	//
	//     * Redis
	// Multi-AZ with automatic failover is not supported on T1 instances.
	//
	//     * Redis
	// configuration variables appendonly and appendfsync are not supported on Redis
	// version 2.8.22 and later.
	CacheNodeType *string

	// The duration filter value, specified in years or seconds. Use this parameter to
	// show only reservations for this duration. Valid Values: 1 | 3 | 31536000 |
	// 94608000
	Duration *string

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a marker is included in the response so
	// that the remaining results can be retrieved. Default: 100 Constraints: minimum
	// 20; maximum 100.
	MaxRecords *int32

	// The offering type filter value. Use this parameter to show only the available
	// offerings matching the specified offering type. Valid values: "Light
	// Utilization"|"Medium Utilization"|"Heavy Utilization"
	OfferingType *string

	// The product description filter value. Use this parameter to show only those
	// reservations matching the specified product description.
	ProductDescription *string

	// The reserved cache node identifier filter value. Use this parameter to show only
	// the reservation that matches the specified reservation ID.
	ReservedCacheNodeId *string

	// The offering identifier filter value. Use this parameter to show only purchased
	// reservations matching the specified offering identifier.
	ReservedCacheNodesOfferingId *string
}

type DescribeReservedCacheNodesOfferingsInput struct {

	// The cache node type filter value. Use this parameter to show only the available
	// offerings matching the specified cache node type. 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: M5 node types: cache.m5.large, cache.m5.xlarge,
	// cache.m5.2xlarge, cache.m5.4xlarge, cache.m5.12xlarge, cache.m5.24xlarge M4 node
	// types: cache.m4.large, cache.m4.xlarge, cache.m4.2xlarge, cache.m4.4xlarge,
	// cache.m4.10xlarge T3 node types: cache.t3.micro, cache.t3.small, cache.t3.medium
	// T2 node types: cache.t2.micro, cache.t2.small, cache.t2.medium
	//
	//         *
	// Previous generation: (not recommended) T1 node types: cache.t1.micro M1 node
	// types: cache.m1.small, cache.m1.medium, cache.m1.large, cache.m1.xlarge M3 node
	// types: cache.m3.medium, cache.m3.large, cache.m3.xlarge, cache.m3.2xlarge
	//
	//     *
	// Compute optimized:
	//
	//         * Previous generation: (not recommended) C1 node
	// types: cache.c1.xlarge
	//
	//     * Memory optimized:
	//
	//         * Current generation:
	// R5 node types: cache.r5.large, cache.r5.xlarge, cache.r5.2xlarge,
	// cache.r5.4xlarge, cache.r5.12xlarge, cache.r5.24xlarge R4 node types:
	// cache.r4.large, cache.r4.xlarge, cache.r4.2xlarge, cache.r4.4xlarge,
	// cache.r4.8xlarge, cache.r4.16xlarge
	//
	//         * Previous generation: (not
	// recommended) M2 node types: cache.m2.xlarge, cache.m2.2xlarge, cache.m2.4xlarge
	// R3 node types: cache.r3.large, cache.r3.xlarge, cache.r3.2xlarge,
	//
	//
	// cache.r3.4xlarge, cache.r3.8xlarge
	//
	// Additional node type info
	//
	//     * All current
	// generation instance types are created in Amazon VPC by default.
	//
	//     * Redis
	// append-only files (AOF) are not supported for T1 or T2 instances.
	//
	//     * Redis
	// Multi-AZ with automatic failover is not supported on T1 instances.
	//
	//     * Redis
	// configuration variables appendonly and appendfsync are not supported on Redis
	// version 2.8.22 and later.
	CacheNodeType *string

	// Duration filter value, specified in years or seconds. Use this parameter to show
	// only reservations for a given duration. Valid Values: 1 | 3 | 31536000 |
	// 94608000
	Duration *string

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a marker is included in the response so
	// that the remaining results can be retrieved. Default: 100 Constraints: minimum
	// 20; maximum 100.
	MaxRecords *int32

	// The offering type filter value. Use this parameter to show only the available
	// offerings matching the specified offering type. Valid Values: "Light
	// Utilization"|"Medium Utilization"|"Heavy Utilization"
	OfferingType *string

	// The product description filter value. Use this parameter to show only the
	// available offerings matching the specified product description.
	ProductDescription *string

	// The offering identifier filter value. Use this parameter to show only the
	// available offering that matches the specified reservation identifier. Example:
	// 438012d3-4052-4cc7-b2e3-8d3372e0e706
	ReservedCacheNodesOfferingId *string
}

type DescribeReservedCacheNodesOfferingsOutput struct {

	// Provides an identifier to allow retrieval of paginated results.
	Marker *string

	// A list of reserved cache node offerings. Each element in the list contains
	// detailed information about one offering.
	ReservedCacheNodesOfferings []*types.ReservedCacheNodesOffering

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeReservedCacheNodesOutput struct {

	// Provides an identifier to allow retrieval of paginated results.
	Marker *string

	// A list of reserved cache nodes. Each element in the list contains detailed
	// information about one node.
	ReservedCacheNodes []*types.ReservedCacheNode

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeServiceUpdatesInput struct {

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response
	MaxRecords *int32

	// The unique ID of the service update
	ServiceUpdateName *string

	// The status of the service update
	ServiceUpdateStatus []types.ServiceUpdateStatus
}

type DescribeServiceUpdatesOutput struct {

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// A list of service updates
	ServiceUpdates []*types.ServiceUpdate

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeSnapshotsInput struct {

	// A user-supplied cluster identifier. If this parameter is specified, only
	// snapshots associated with that specific cluster are described.
	CacheClusterId *string

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response. If more records exist
	// than the specified MaxRecords value, a marker is included in the response so
	// that the remaining results can be retrieved. Default: 50 Constraints: minimum
	// 20; maximum 50.
	MaxRecords *int32

	// A user-supplied replication group identifier. If this parameter is specified,
	// only snapshots associated with that specific replication group are described.
	ReplicationGroupId *string

	// A Boolean value which if true, the node group (shard) configuration is included
	// in the snapshot description.
	ShowNodeGroupConfig *bool

	// A user-supplied name of the snapshot. If this parameter is specified, only this
	// snapshot are described.
	SnapshotName *string

	// If set to system, the output shows snapshots that were automatically created by
	// ElastiCache. If set to user the output shows snapshots that were manually
	// created. If omitted, the output shows both automatically and manually created
	// snapshots.
	SnapshotSource *string
}

type DescribeSnapshotsOutput struct {

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// A list of snapshots. Each item in the list contains detailed information about
	// one snapshot.
	Snapshots []*types.Snapshot

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeUpdateActionsInput struct {

	// The cache cluster IDs
	CacheClusterIds []*string

	// The Elasticache engine to which the update applies. Either Redis or Memcached
	Engine *string

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// The maximum number of records to include in the response
	MaxRecords *int32

	// The replication group IDs
	ReplicationGroupIds []*string

	// The unique ID of the service update
	ServiceUpdateName *string

	// The status of the service update
	ServiceUpdateStatus []types.ServiceUpdateStatus

	// The range of time specified to search for service updates that are in available
	// status
	ServiceUpdateTimeRange *types.TimeRangeFilter

	// Dictates whether to include node level update status in the response
	ShowNodeLevelUpdateStatus *bool

	// The status of the update action.
	UpdateActionStatus []types.UpdateActionStatus
}

type DescribeUpdateActionsOutput struct {

	// An optional marker returned from a prior request. Use this marker for pagination
	// of results from this operation. If this parameter is specified, the response
	// includes only records beyond the marker, up to the value specified by
	// MaxRecords.
	Marker *string

	// Returns a list of update actions
	UpdateActions []*types.UpdateAction

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DisassociateGlobalReplicationGroupInput struct {

	// The name of the Global Datastore
	//
	// This member is required.
	GlobalReplicationGroupId *string

	// The name of the secondary cluster you wish to remove from the Global Datastore
	//
	// This member is required.
	ReplicationGroupId *string

	// The AWS region of secondary cluster you wish to remove from the Global Datastore
	//
	// This member is required.
	ReplicationGroupRegion *string
}

type DisassociateGlobalReplicationGroupOutput struct {

	// Consists of a primary cluster that accepts writes and an associated secondary
	// cluster that resides in a different AWS region. The secondary cluster accepts
	// only reads. The primary cluster automatically replicates updates to the
	// secondary cluster.
	//
	//     * The GlobalReplicationGroupIdSuffix represents the name
	// of the Global Datastore, which is what you use to associate a secondary cluster.
	GlobalReplicationGroup *types.GlobalReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type EndpointResolver interface {
	ResolveEndpoint(region string, options ResolverOptions) (aws.Endpoint, error)
}

type EndpointResolverFunc func(region string, options ResolverOptions) (aws.Endpoint, error)

type FailoverGlobalReplicationGroupInput struct {

	// The name of the Global Datastore
	//
	// This member is required.
	GlobalReplicationGroupId *string

	// The AWS region of the primary cluster of the Global Datastore
	//
	// This member is required.
	PrimaryRegion *string

	// The name of the primary replication group
	//
	// This member is required.
	PrimaryReplicationGroupId *string
}

type FailoverGlobalReplicationGroupOutput struct {

	// Consists of a primary cluster that accepts writes and an associated secondary
	// cluster that resides in a different AWS region. The secondary cluster accepts
	// only reads. The primary cluster automatically replicates updates to the
	// secondary cluster.
	//
	//     * The GlobalReplicationGroupIdSuffix represents the name
	// of the Global Datastore, which is what you use to associate a secondary cluster.
	GlobalReplicationGroup *types.GlobalReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type HTTPClient interface {
	Do(*http.Request) (*http.Response, error)
}

type HTTPSignerV4 interface {
	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time) error
}

type IncreaseNodeGroupsInGlobalReplicationGroupInput struct {

	// Indicates that the process begins immediately. At present, the only permitted
	// value for this parameter is true.
	//
	// This member is required.
	ApplyImmediately *bool

	// The name of the Global Datastore
	//
	// This member is required.
	GlobalReplicationGroupId *string

	// The number of node groups you wish to add
	//
	// This member is required.
	NodeGroupCount *int32

	// Describes the replication group IDs, the AWS regions where they are stored and
	// the shard configuration for each that comprise the Global Datastore
	RegionalConfigurations []*types.RegionalConfiguration
}

type IncreaseNodeGroupsInGlobalReplicationGroupOutput struct {

	// Consists of a primary cluster that accepts writes and an associated secondary
	// cluster that resides in a different AWS region. The secondary cluster accepts
	// only reads. The primary cluster automatically replicates updates to the
	// secondary cluster.
	//
	//     * The GlobalReplicationGroupIdSuffix represents the name
	// of the Global Datastore, which is what you use to associate a secondary cluster.
	GlobalReplicationGroup *types.GlobalReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type IncreaseReplicaCountInput struct {

	// If True, the number of replica nodes is increased immediately.
	// ApplyImmediately=False is not currently supported.
	//
	// This member is required.
	ApplyImmediately *bool

	// The id of the replication group to which you want to add replica nodes.
	//
	// This member is required.
	ReplicationGroupId *string

	// The number of read replica nodes you want at the completion of this operation.
	// For Redis (cluster mode disabled) replication groups, this is the number of
	// replica nodes in the replication group. For Redis (cluster mode enabled)
	// replication groups, this is the number of replica nodes in each of the
	// replication group's node groups.
	NewReplicaCount *int32

	// A list of ConfigureShard objects that can be used to configure each shard in a
	// Redis (cluster mode enabled) replication group. The ConfigureShard has three
	// members: NewReplicaCount, NodeGroupId, and PreferredAvailabilityZones.
	ReplicaConfiguration []*types.ConfigureShard
}

type IncreaseReplicaCountOutput struct {

	// Contains all of the attributes of a specific Redis replication group.
	ReplicationGroup *types.ReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListAllowedNodeTypeModificationsInput struct {

	// The name of the cluster you want to scale up to a larger node instanced type.
	// ElastiCache uses the cluster id to identify the current node type of this
	// cluster and from that to create a list of node types you can scale up to. You
	// must provide a value for either the CacheClusterId or the ReplicationGroupId.
	CacheClusterId *string

	// The name of the replication group want to scale up to a larger node type.
	// ElastiCache uses the replication group id to identify the current node type
	// being used by this replication group, and from that to create a list of node
	// types you can scale up to. You must provide a value for either the
	// CacheClusterId or the ReplicationGroupId.
	ReplicationGroupId *string
}

type ListAllowedNodeTypeModificationsOutput struct {

	// A string list, each element of which specifies a cache node type which you can
	// use to scale your cluster or replication group. When scaling down a Redis
	// cluster or replication group using ModifyCacheCluster or ModifyReplicationGroup,
	// use a value from this list for the CacheNodeType parameter.
	ScaleDownModifications []*string

	// A string list, each element of which specifies a cache node type which you can
	// use to scale your cluster or replication group. When scaling up a Redis cluster
	// or replication group using ModifyCacheCluster or ModifyReplicationGroup, use a
	// value from this list for the CacheNodeType parameter.
	ScaleUpModifications []*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListTagsForResourceInput struct {

	// The Amazon Resource Name (ARN) of the resource for which you want the list of
	// tags, for example arn:aws:elasticache:us-west-2:0123456789:cluster:myCluster or
	// arn:aws:elasticache:us-west-2:0123456789:snapshot:mySnapshot. For more
	// information about ARNs, see Amazon Resource Names (ARNs) and AWS Service
	// Namespaces
	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
	//
	// This member is required.
	ResourceName *string
}

type ListTagsForResourceOutput struct {

	// A list of cost allocation tags as key-value pairs.
	TagList []*types.Tag

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ModifyCacheClusterInput struct {

	// The cluster identifier. This value is stored as a lowercase string.
	//
	// This member is required.
	CacheClusterId *string

	// Specifies whether the new nodes in this Memcached cluster are all created in a
	// single Availability Zone or created across multiple Availability Zones. Valid
	// values: single-az | cross-az. This option is only supported for Memcached
	// clusters. You cannot specify single-az if the Memcached cluster already has
	// cache nodes in different Availability Zones. If cross-az is specified, existing
	// Memcached nodes remain in their current Availability Zone. Only newly created
	// nodes are located in different Availability Zones.
	AZMode types.AZMode

	// If true, this parameter causes the modifications in this request and any pending
	// modifications to be applied, asynchronously and as soon as possible, regardless
	// of the PreferredMaintenanceWindow setting for the cluster. If false, changes to
	// the cluster are applied on the next maintenance reboot, or the next failure
	// reboot, whichever occurs first. If you perform a ModifyCacheCluster before a
	// pending modification is applied, the pending modification is replaced by the
	// newer modification. Valid values: true | false Default: false
	ApplyImmediately *bool

	// Reserved parameter. The password used to access a password protected server.
	// This parameter must be specified with the auth-token-update parameter. Password
	// constraints:
	//
	//     * Must be only printable ASCII characters
	//
	//     * Must be at
	// least 16 characters and no more than 128 characters in length
	//
	//     * Cannot
	// contain any of the following characters: '/', '"', or '@', '%'
	//
	// For more
	// information, see AUTH password at AUTH (http://redis.io/commands/AUTH).
	AuthToken *string

	// Specifies the strategy to use to update the AUTH token. This parameter must be
	// specified with the auth-token parameter. Possible values:
	//
	//     * Rotate
	//
	//     *
	// Set
	//
	// For more information, see Authenticating Users with Redis AUTH
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/auth.html)
	AuthTokenUpdateStrategy types.AuthTokenUpdateStrategyType

	// This parameter is currently disabled.
	AutoMinorVersionUpgrade *bool

	// A list of cache node IDs to be removed. A node ID is a numeric identifier (0001,
	// 0002, etc.). This parameter is only valid when NumCacheNodes is less than the
	// existing number of cache nodes. The number of cache node IDs supplied in this
	// parameter must match the difference between the existing number of cache nodes
	// in the cluster or pending cache nodes, whichever is greater, and the value of
	// NumCacheNodes in the request. For example: If you have 3 active cache nodes, 7
	// pending cache nodes, and the number of cache nodes in this ModifyCacheCluster
	// call is 5, you must list 2 (7 - 5) cache node IDs to remove.
	CacheNodeIdsToRemove []*string

	// A valid cache node type that you want to scale this cluster up to.
	CacheNodeType *string

	// The name of the cache parameter group to apply to this cluster. This change is
	// asynchronously applied as soon as possible for parameters when the
	// ApplyImmediately parameter is specified as true for this request.
	CacheParameterGroupName *string

	// A list of cache security group names to authorize on this cluster. This change
	// is asynchronously applied as soon as possible. You can use this parameter only
	// with clusters that are created outside of an Amazon Virtual Private Cloud
	// (Amazon VPC). Constraints: Must contain no more than 255 alphanumeric
	// characters. Must not be "Default".
	CacheSecurityGroupNames []*string

	// The upgraded version of the cache engine to be run on the cache nodes.
	// Important: You can upgrade to a newer engine version (see Selecting a Cache
	// Engine and Version
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/SelectEngine.html#VersionManagement)),
	// but you cannot downgrade to an earlier engine version. If you want to use an
	// earlier engine version, you must delete the existing cluster and create it anew
	// with the earlier engine version.
	EngineVersion *string

	// The list of Availability Zones where the new Memcached cache nodes are created.
	// This parameter is only valid when NumCacheNodes in the request is greater than
	// the sum of the number of active cache nodes and the number of cache nodes
	// pending creation (which may be zero). The number of Availability Zones supplied
	// in this list must match the cache nodes being added in this request. This option
	// is only supported on Memcached clusters. Scenarios:
	//
	//     * Scenario 1: You have
	// 3 active nodes and wish to add 2 nodes. Specify NumCacheNodes=5 (3 + 2) and
	// optionally specify two Availability Zones for the two new nodes.
	//
	//     * Scenario
	// 2: You have 3 active nodes and 2 nodes pending creation (from the scenario 1
	// call) and want to add 1 more node. Specify NumCacheNodes=6 ((3 + 2) + 1) and
	// optionally specify an Availability Zone for the new node.
	//
	//     * Scenario 3: You
	// want to cancel all pending operations. Specify NumCacheNodes=3 to cancel all
	// pending operations.
	//
	// The Availability Zone placement of nodes pending creation
	// cannot be modified. If you wish to cancel any nodes pending creation, add 0
	// nodes by setting NumCacheNodes to the number of current nodes. If cross-az is
	// specified, existing Memcached nodes remain in their current Availability Zone.
	// Only newly created nodes can be located in different Availability Zones. For
	// guidance on how to move existing Memcached nodes to different Availability
	// Zones, see the Availability Zone Considerations section of Cache Node
	// Considerations for Memcached
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/CacheNodes.SupportedTypes.html).
	// Impact of new add/remove requests upon pending requests
	//
	//     * Scenario-1
	//
	//
	// * Pending Action: Delete
	//
	//         * New Request: Delete
	//
	//         * Result: The
	// new delete, pending or immediate, replaces the pending delete.
	//
	//     *
	// Scenario-2
	//
	//         * Pending Action: Delete
	//
	//         * New Request: Create
	//
	//
	// * Result: The new create, pending or immediate, replaces the pending delete.
	//
	//
	// * Scenario-3
	//
	//         * Pending Action: Create
	//
	//         * New Request: Delete
	//
	//
	// * Result: The new delete, pending or immediate, replaces the pending create.
	//
	//
	// * Scenario-4
	//
	//         * Pending Action: Create
	//
	//         * New Request: Create
	//
	//
	// * Result: The new create is added to the pending create. Important: If the new
	// create request is Apply Immediately - Yes, all creates are performed
	// immediately. If the new create request is Apply Immediately - No, all creates
	// are pending.
	NewAvailabilityZones []*string

	// The Amazon Resource Name (ARN) of the Amazon SNS topic to which notifications
	// are sent. The Amazon SNS topic owner must be same as the cluster owner.
	NotificationTopicArn *string

	// The status of the Amazon SNS notification topic. Notifications are sent only if
	// the status is active. Valid values: active | inactive
	NotificationTopicStatus *string

	// The number of cache nodes that the cluster should have. If the value for
	// NumCacheNodes is greater than the sum of the number of current cache nodes and
	// the number of cache nodes pending creation (which may be zero), more nodes are
	// added. If the value is less than the number of existing cache nodes, nodes are
	// removed. If the value is equal to the number of current cache nodes, any pending
	// add or remove requests are canceled. If you are removing cache nodes, you must
	// use the CacheNodeIdsToRemove parameter to provide the IDs of the specific cache
	// nodes to remove. For clusters running Redis, this value must be 1. For clusters
	// running Memcached, this value must be between 1 and 20. Adding or removing
	// Memcached cache nodes can be applied immediately or as a pending operation (see
	// ApplyImmediately). A pending operation to modify the number of cache nodes in a
	// cluster during its maintenance window, whether by adding or removing nodes in
	// accordance with the scale out architecture, is not queued. The customer's latest
	// request to add or remove nodes to the cluster overrides any previous pending
	// operations to modify the number of cache nodes in the cluster. For example, a
	// request to remove 2 nodes would override a previous pending operation to remove
	// 3 nodes. Similarly, a request to add 2 nodes would override a previous pending
	// operation to remove 3 nodes and vice versa. As Memcached cache nodes may now be
	// provisioned in different Availability Zones with flexible cache node placement,
	// a request to add nodes does not automatically override a previous pending
	// operation to add nodes. The customer can modify the previous pending operation
	// to add more nodes or explicitly cancel the pending request and retry the new
	// request. To cancel pending operations to modify the number of cache nodes in a
	// cluster, use the ModifyCacheCluster request and set NumCacheNodes equal to the
	// number of cache nodes currently in the cluster.
	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

	// Specifies the VPC Security Groups associated with the cluster. This parameter
	// can be used only with clusters that are created in an Amazon Virtual Private
	// Cloud (Amazon VPC).
	SecurityGroupIds []*string

	// 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 daily time range (in UTC) during which ElastiCache begins taking a daily
	// snapshot of your cluster.
	SnapshotWindow *string
}

type ModifyCacheClusterOutput struct {

	// Contains all of the attributes of a specific cluster.
	CacheCluster *types.CacheCluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ModifyCacheParameterGroupInput struct {

	// The name of the cache parameter group to modify.
	//
	// This member is required.
	CacheParameterGroupName *string

	// An array of parameter names and values for the parameter update. You must supply
	// at least one parameter name and value; subsequent arguments are optional. A
	// maximum of 20 parameters may be modified per request.
	//
	// This member is required.
	ParameterNameValues []*types.ParameterNameValue
}

type ModifyCacheParameterGroupOutput struct {

	// The name of the cache parameter group.
	CacheParameterGroupName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ModifyCacheSubnetGroupInput struct {

	// The name for the cache subnet group. This value is stored as a lowercase string.
	// Constraints: Must contain no more than 255 alphanumeric characters or hyphens.
	// Example: mysubnetgroup
	//
	// This member is required.
	CacheSubnetGroupName *string

	// A description of the cache subnet group.
	CacheSubnetGroupDescription *string

	// The EC2 subnet IDs for the cache subnet group.
	SubnetIds []*string
}

type ModifyCacheSubnetGroupOutput struct {

	// Represents the output of one of the following operations:
	//
	//     *
	// CreateCacheSubnetGroup
	//
	//     * ModifyCacheSubnetGroup
	CacheSubnetGroup *types.CacheSubnetGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ModifyGlobalReplicationGroupInput struct {

	// This parameter causes the modifications in this request and any pending
	// modifications to be applied, asynchronously and as soon as possible.
	// Modifications to Global Replication Groups cannot be requested to be applied in
	// PreferredMaintenceWindow.
	//
	// This member is required.
	ApplyImmediately *bool

	// The name of the Global Datastore
	//
	// This member is required.
	GlobalReplicationGroupId *string

	// Determines whether a read replica is automatically promoted to read/write
	// primary if the existing primary encounters a failure.
	AutomaticFailoverEnabled *bool

	// A valid cache node type that you want to scale this Global Datastore to.
	CacheNodeType *string

	// The upgraded version of the cache engine to be run on the clusters in the Global
	// Datastore.
	EngineVersion *string

	// A description of the Global Datastore
	GlobalReplicationGroupDescription *string
}

type ModifyGlobalReplicationGroupOutput struct {

	// Consists of a primary cluster that accepts writes and an associated secondary
	// cluster that resides in a different AWS region. The secondary cluster accepts
	// only reads. The primary cluster automatically replicates updates to the
	// secondary cluster.
	//
	//     * The GlobalReplicationGroupIdSuffix represents the name
	// of the Global Datastore, which is what you use to associate a secondary cluster.
	GlobalReplicationGroup *types.GlobalReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ModifyReplicationGroupInput struct {

	// The identifier of the replication group to modify.
	//
	// This member is required.
	ReplicationGroupId *string

	// If true, this parameter causes the modifications in this request and any pending
	// modifications to be applied, asynchronously and as soon as possible, regardless
	// of the PreferredMaintenanceWindow setting for the replication group. If false,
	// changes to the nodes in the replication group are applied on the next
	// maintenance reboot, or the next failure reboot, whichever occurs first. Valid
	// values: true | false Default: false
	ApplyImmediately *bool

	// Reserved parameter. The password used to access a password protected server.
	// This parameter must be specified with the auth-token-update-strategy  parameter.
	// Password constraints:
	//
	//     * Must be only printable ASCII characters
	//
	//     * Must
	// be at least 16 characters and no more than 128 characters in length
	//
	//     *
	// Cannot contain any of the following characters: '/', '"', or '@', '%'
	//
	// For more
	// information, see AUTH password at AUTH (http://redis.io/commands/AUTH).
	AuthToken *string

	// Specifies the strategy to use to update the AUTH token. This parameter must be
	// specified with the auth-token parameter. Possible values:
	//
	//     * Rotate
	//
	//     *
	// Set
	//
	// For more information, see Authenticating Users with Redis AUTH
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/auth.html)
	AuthTokenUpdateStrategy types.AuthTokenUpdateStrategyType

	// This parameter is currently disabled.
	AutoMinorVersionUpgrade *bool

	// Determines whether a read replica is automatically promoted to read/write
	// primary if the existing primary encounters a failure. Valid values: true | false
	AutomaticFailoverEnabled *bool

	// A valid cache node type that you want to scale this replication group to.
	CacheNodeType *string

	// The name of the cache parameter group to apply to all of the clusters in this
	// replication group. This change is asynchronously applied as soon as possible for
	// parameters when the ApplyImmediately parameter is specified as true for this
	// request.
	CacheParameterGroupName *string

	// A list of cache security group names to authorize for the clusters in this
	// replication group. This change is asynchronously applied as soon as possible.
	// This parameter can be used only with replication group containing clusters
	// running outside of an Amazon Virtual Private Cloud (Amazon VPC). Constraints:
	// Must contain no more than 255 alphanumeric characters. Must not be Default.
	CacheSecurityGroupNames []*string

	// The upgraded version of the cache engine to be run on the clusters in the
	// replication group. Important: You can upgrade to a newer engine version (see
	// Selecting a Cache Engine and Version
	// (https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/SelectEngine.html#VersionManagement)),
	// but you cannot downgrade to an earlier engine version. If you want to use an
	// earlier engine version, you must delete the existing replication group and
	// create it anew with the earlier engine version.
	EngineVersion *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).
	MultiAZEnabled *bool

	// Deprecated. This parameter is not used.
	NodeGroupId *string

	// The Amazon Resource Name (ARN) of the Amazon SNS topic to which notifications
	// are sent. The Amazon SNS topic owner must be same as the replication group
	// owner.
	NotificationTopicArn *string

	// The status of the Amazon SNS notification topic for the replication group.
	// Notifications are sent only if the status is active. Valid values: active |
	// inactive
	NotificationTopicStatus *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

	// For replication groups with a single primary, if this parameter is specified,
	// ElastiCache promotes the specified cluster in the specified replication group to
	// the primary role. The nodes of all other clusters in the replication group are
	// read replicas.
	PrimaryClusterId *string

	// A description for the replication group. Maximum length is 255 characters.
	ReplicationGroupDescription *string

	// Specifies the VPC Security Groups associated with the clusters in the
	// replication group. This parameter can be used only with replication group
	// containing clusters running in an Amazon Virtual Private Cloud (Amazon VPC).
	SecurityGroupIds []*string

	// The number of days for which ElastiCache retains automatic node group (shard)
	// 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. Important If the value of SnapshotRetentionLimit is set to zero (0),
	// backups are turned off.
	SnapshotRetentionLimit *int32

	// The daily time range (in UTC) during which ElastiCache begins taking a daily
	// snapshot of the node group (shard) specified by SnapshottingClusterId. Example:
	// 05:00-09:00 If you do not specify this parameter, ElastiCache automatically
	// chooses an appropriate time range.
	SnapshotWindow *string

	// The cluster ID that is used as the daily snapshot source for the replication
	// group. This parameter cannot be set for Redis (cluster mode enabled) replication
	// groups.
	SnapshottingClusterId *string
}

type ModifyReplicationGroupOutput struct {

	// Contains all of the attributes of a specific Redis replication group.
	ReplicationGroup *types.ReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ModifyReplicationGroupShardConfigurationInput struct {

	// Indicates that the shard reconfiguration process begins immediately. At present,
	// the only permitted value for this parameter is true. Value: true
	//
	// This member is required.
	ApplyImmediately *bool

	// The number of node groups (shards) that results from the modification of the
	// shard configuration.
	//
	// This member is required.
	NodeGroupCount *int32

	// The name of the Redis (cluster mode enabled) cluster (replication group) on
	// which the shards are to be configured.
	//
	// This member is required.
	ReplicationGroupId *string

	// If the value of NodeGroupCount is less than the current number of node groups
	// (shards), then either NodeGroupsToRemove or NodeGroupsToRetain is required.
	// NodeGroupsToRemove is a list of NodeGroupIds to remove from the cluster.
	// ElastiCache for Redis will attempt to remove all node groups listed by
	// NodeGroupsToRemove from the cluster.
	NodeGroupsToRemove []*string

	// If the value of NodeGroupCount is less than the current number of node groups
	// (shards), then either NodeGroupsToRemove or NodeGroupsToRetain is required.
	// NodeGroupsToRetain is a list of NodeGroupIds to retain in the cluster.
	// ElastiCache for Redis will attempt to remove all node groups except those listed
	// by NodeGroupsToRetain from the cluster.
	NodeGroupsToRetain []*string

	// Specifies the preferred availability zones for each node group in the cluster.
	// If the value of NodeGroupCount is greater than the current number of node groups
	// (shards), you can use this parameter to specify the preferred availability zones
	// of the cluster's shards. If you omit this parameter ElastiCache selects
	// availability zones for you. You can specify this parameter only if the value of
	// NodeGroupCount is greater than the current number of node groups (shards).
	ReshardingConfiguration []*types.ReshardingConfiguration
}

type ModifyReplicationGroupShardConfigurationOutput struct {

	// Contains all of the attributes of a specific Redis replication group.
	ReplicationGroup *types.ReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Options struct {
	// Set of options to modify how an operation is invoked. These apply to all
	// operations invoked for this client. Use functional options on operation call to
	// modify this list for per operation behavior.
	APIOptions []func(*middleware.Stack) error

	// The credentials object to use when signing requests.
	Credentials aws.CredentialsProvider

	// The endpoint options to be used when attempting to resolve an endpoint.
	EndpointOptions ResolverOptions

	// The service endpoint resolver.
	EndpointResolver EndpointResolver

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// The region to send requests to. (Required)
	Region string

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer.
	Retryer retry.Retryer

	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
	// implementation if nil.
	HTTPClient HTTPClient
}

type PurchaseReservedCacheNodesOfferingInput struct {

	// The ID of the reserved cache node offering to purchase. Example:
	// 438012d3-4052-4cc7-b2e3-8d3372e0e706
	//
	// This member is required.
	ReservedCacheNodesOfferingId *string

	// The number of cache node instances to reserve. Default: 1
	CacheNodeCount *int32

	// A customer-specified identifier to track this reservation. The Reserved Cache
	// Node ID is an unique customer-specified identifier to track this reservation. If
	// this parameter is not specified, ElastiCache automatically generates an
	// identifier for the reservation. Example: myreservationID
	ReservedCacheNodeId *string
}

type PurchaseReservedCacheNodesOfferingOutput struct {

	// Represents the output of a PurchaseReservedCacheNodesOffering operation.
	ReservedCacheNode *types.ReservedCacheNode

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type RebalanceSlotsInGlobalReplicationGroupInput struct {

	// If True, redistribution is applied immediately.
	//
	// This member is required.
	ApplyImmediately *bool

	// The name of the Global Datastore
	//
	// This member is required.
	GlobalReplicationGroupId *string
}

type RebalanceSlotsInGlobalReplicationGroupOutput struct {

	// Consists of a primary cluster that accepts writes and an associated secondary
	// cluster that resides in a different AWS region. The secondary cluster accepts
	// only reads. The primary cluster automatically replicates updates to the
	// secondary cluster.
	//
	//     * The GlobalReplicationGroupIdSuffix represents the name
	// of the Global Datastore, which is what you use to associate a secondary cluster.
	GlobalReplicationGroup *types.GlobalReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type RebootCacheClusterInput struct {

	// The cluster identifier. This parameter is stored as a lowercase string.
	//
	// This member is required.
	CacheClusterId *string

	// A list of cache node IDs to reboot. A node ID is a numeric identifier (0001,
	// 0002, etc.). To reboot an entire cluster, specify all of the cache node IDs.
	//
	// This member is required.
	CacheNodeIdsToReboot []*string
}

type RebootCacheClusterOutput struct {

	// Contains all of the attributes of a specific cluster.
	CacheCluster *types.CacheCluster

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type RemoveTagsFromResourceInput struct {

	// The Amazon Resource Name (ARN) of the resource from which you want the tags
	// removed, for example arn:aws:elasticache:us-west-2:0123456789:cluster:myCluster
	// or arn:aws:elasticache:us-west-2:0123456789:snapshot:mySnapshot. For more
	// information about ARNs, see Amazon Resource Names (ARNs) and AWS Service
	// Namespaces
	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
	//
	// This member is required.
	ResourceName *string

	// A list of TagKeys identifying the tags you want removed from the named resource.
	//
	// This member is required.
	TagKeys []*string
}

type RemoveTagsFromResourceOutput struct {

	// A list of cost allocation tags as key-value pairs.
	TagList []*types.Tag

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ResetCacheParameterGroupInput struct {

	// The name of the cache parameter group to reset.
	//
	// This member is required.
	CacheParameterGroupName *string

	// An array of parameter names to reset to their default values. If
	// ResetAllParameters is true, do not use ParameterNameValues. If
	// ResetAllParameters is false, you must specify the name of at least one parameter
	// to reset.
	ParameterNameValues []*types.ParameterNameValue

	// If true, all parameters in the cache parameter group are reset to their default
	// values. If false, only the parameters listed by ParameterNameValues are reset to
	// their default values. Valid values: true | false
	ResetAllParameters *bool
}

type ResetCacheParameterGroupOutput struct {

	// The name of the cache parameter group.
	CacheParameterGroupName *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  ResolverOptions
}

type ResolverOptions = internalendpoints.Options

type RevokeCacheSecurityGroupIngressInput struct {

	// The name of the cache security group to revoke ingress from.
	//
	// This member is required.
	CacheSecurityGroupName *string

	// The name of the Amazon EC2 security group to revoke access from.
	//
	// This member is required.
	EC2SecurityGroupName *string

	// The AWS account number of the Amazon EC2 security group owner. Note that this is
	// not the same thing as an AWS access key ID - you must provide a valid AWS
	// account number for this parameter.
	//
	// This member is required.
	EC2SecurityGroupOwnerId *string
}

type RevokeCacheSecurityGroupIngressOutput struct {

	// Represents the output of one of the following operations:
	//
	//     *
	// AuthorizeCacheSecurityGroupIngress
	//
	//     * CreateCacheSecurityGroup
	//
	//     *
	// RevokeCacheSecurityGroupIngress
	CacheSecurityGroup *types.CacheSecurityGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type StartMigrationInput struct {

	// List of endpoints from which data should be migrated. For Redis (cluster mode
	// disabled), list should have only one element.
	//
	// This member is required.
	CustomerNodeEndpointList []*types.CustomerNodeEndpoint

	// The ID of the replication group to which data should be migrated.
	//
	// This member is required.
	ReplicationGroupId *string
}

type StartMigrationOutput struct {

	// Contains all of the attributes of a specific Redis replication group.
	ReplicationGroup *types.ReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type TestFailoverInput struct {

	// The name of the node group (called shard in the console) in this replication
	// group on which automatic failover is to be tested. You may test automatic
	// failover on up to 5 node groups in any rolling 24-hour period.
	//
	// This member is required.
	NodeGroupId *string

	// The name of the replication group (console: cluster) whose automatic failover is
	// being tested by this operation.
	//
	// This member is required.
	ReplicationGroupId *string
}

type TestFailoverOutput struct {

	// Contains all of the attributes of a specific Redis replication group.
	ReplicationGroup *types.ReplicationGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}