elasticache

type AddTagsToResourceInput struct {
	// 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.
	Tags []*types.Tag
	// 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).
	ResourceName *string
}

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 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.
	EC2SecurityGroupOwnerId *string
	// The Amazon EC2 security group to be authorized for ingress to the cache security
	// group.
	EC2SecurityGroupName *string
	// The cache security group that allows network ingress.
	CacheSecurityGroupName *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 replication group IDs
	ReplicationGroupIds []*string
	// The cache cluster IDs
	CacheClusterIds []*string
	// The unique ID of the service update
	ServiceUpdateName *string
}

type BatchApplyUpdateActionOutput struct {
	// Update actions that haven't been processed successfully
	UnprocessedUpdateActions []*types.UnprocessedUpdateAction
	// Update actions that have been processed successfully
	ProcessedUpdateActions []*types.ProcessedUpdateAction

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

type BatchStopUpdateActionInput struct {
	// The replication group IDs
	ReplicationGroupIds []*string
	// The cache cluster IDs
	CacheClusterIds []*string
	// The unique ID of the service update
	ServiceUpdateName *string
}

type BatchStopUpdateActionOutput struct {
	// Update actions that haven't been processed successfully
	UnprocessedUpdateActions []*types.UnprocessedUpdateAction
	// Update actions that have been processed successfully
	ProcessedUpdateActions []*types.ProcessedUpdateAction

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

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

type CompleteMigrationInput struct {
	// 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
	// The ID of the replication group to which data is being migrated.
	ReplicationGroupId *string
}

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 ID of the KMS key used to encrypt the target snapshot.
	KmsKeyId *string
	// The name of an existing snapshot from which to make a copy.
	SourceSnapshotName *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.  <p>For more information, see <a
	// href="https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Snapshots.Exporting.html">Exporting
	// a Snapshot</a> in the <i>Amazon ElastiCache User Guide</i>.</p>
	TargetBucket *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.
	TargetSnapshotName *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 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
	// The name of the cache engine to be used for this cluster. Valid values for this
	// parameter are: memcached | redis
	Engine *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 port number on which each of the cache nodes accepts connections.
	Port *int32
	// 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.
	CacheClusterId *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
	// 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:  <p>Specifies the weekly time range during which maintenance  on
	// the cluster is performed. It is specified as a range in the format
	// ddd:hh24:mi-ddd:hh24:mi (24H Clock UTC). The minimum maintenance window is a 60
	// minute period. Valid values for ddd are:
	//
	//     * sun
	//
	//     * mon
	//
	//     * tue
	//
	//     *
	// wed
	//
	//     * thu
	//
	//     * fri
	//
	//     * sat
	//
	// Example: sun:23:00-mon:01:30
	PreferredMaintenanceWindow *string
	// This parameter is currently disabled.
	AutoMinorVersionUpgrade *bool
	// The version number of the cache engine to be used for this cluster. To view the
	// supported cache engine versions, use the DescribeCacheEngineVersions operation.
	// <p> <b>Important:</b> You can upgrade to a newer engine version (see <a
	// href="https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/SelectEngine.html#VersionManagement">Selecting
	// a Cache Engine and Version</a>), 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. </p>
	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
	// 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
	// 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
	// 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 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:  <p> <b>M5 node types:</b>
	// <code>cache.m5.large</code>, <code>cache.m5.xlarge</code>,
	// <code>cache.m5.2xlarge</code>, <code>cache.m5.4xlarge</code>,
	// <code>cache.m5.12xlarge</code>, <code>cache.m5.24xlarge</code> </p> <p> <b>M4
	// node types:</b> <code>cache.m4.large</code>, <code>cache.m4.xlarge</code>,
	// <code>cache.m4.2xlarge</code>, <code>cache.m4.4xlarge</code>,
	// <code>cache.m4.10xlarge</code> </p> <p> <b>T3 node types:</b>
	// <code>cache.t3.micro</code>, <code>cache.t3.small</code>,
	// <code>cache.t3.medium</code> </p> <p> <b>T2 node types:</b>
	// <code>cache.t2.micro</code>, <code>cache.t2.small</code>,
	// <code>cache.t2.medium</code> </p> </li> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>T1 node types:</b> <code>cache.t1.micro</code> </p> <p>
	// <b>M1 node types:</b> <code>cache.m1.small</code>, <code>cache.m1.medium</code>,
	// <code>cache.m1.large</code>, <code>cache.m1.xlarge</code> </p> <p> <b>M3 node
	// types:</b> <code>cache.m3.medium</code>, <code>cache.m3.large</code>,
	// <code>cache.m3.xlarge</code>, <code>cache.m3.2xlarge</code> </p> </li> </ul>
	// </li> <li> <p>Compute optimized:</p> <ul> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>C1 node types:</b> <code>cache.c1.xlarge</code> </p>
	// </li> </ul> </li> <li> <p>Memory optimized:</p> <ul> <li> <p>Current generation:
	// </p> <p> <b>R5 node types:</b> <code>cache.r5.large</code>,
	// <code>cache.r5.xlarge</code>, <code>cache.r5.2xlarge</code>,
	// <code>cache.r5.4xlarge</code>, <code>cache.r5.12xlarge</code>,
	// <code>cache.r5.24xlarge</code> </p> <p> <b>R4 node types:</b>
	// <code>cache.r4.large</code>, <code>cache.r4.xlarge</code>,
	// <code>cache.r4.2xlarge</code>, <code>cache.r4.4xlarge</code>,
	// <code>cache.r4.8xlarge</code>, <code>cache.r4.16xlarge</code> </p> </li> <li>
	// <p>Previous generation: (not recommended)</p> <p> <b>M2 node types:</b>
	// <code>cache.m2.xlarge</code>, <code>cache.m2.2xlarge</code>,
	// <code>cache.m2.4xlarge</code> </p> <p> <b>R3 node types:</b>
	// <code>cache.r3.large</code>, <code>cache.r3.xlarge</code>,
	// <code>cache.r3.2xlarge</code>, <code>cache.r3.4xlarge</code>,
	// <code>cache.r3.8xlarge</code> </p> </li> </ul> </li> </ul> <p> <b>Additional
	// node type info</b> </p> <ul> <li> <p>All current generation instance types are
	// created in Amazon VPC by default.</p> </li> <li> <p>Redis append-only files
	// (AOF) are not supported for T1 or T2 instances.</p> </li> <li> <p>Redis Multi-AZ
	// with automatic failover is not supported on T1 instances.</p> </li> <li>
	// <p>Redis configuration variables <code>appendonly</code> and
	// <code>appendfsync</code> are not supported on Redis version 2.8.22 and
	// later.</p> </li> </ul>
	CacheNodeType *string
	// The daily time range (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
	// 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
	// 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
	// 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
	// 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
	// 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
	// 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
}

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 {
	// A user-specified name for the cache parameter group.
	CacheParameterGroupName *string
	// 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 |
	CacheParameterGroupFamily *string
	// A user-specified description for the cache parameter group.
	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
	CacheSecurityGroupName *string
	// A description for the cache security group.
	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 list of VPC subnet IDs for the cache subnet group.
	SubnetIds []*string
	// A description for the cache subnet group.
	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
	CacheSubnetGroupName *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.
	GlobalReplicationGroupIdSuffix *string
	// The name of the primary cluster that accepts writes and will replicate updates
	// to the secondary cluster.
	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.  <ul> <li> <p>The <b>GlobalReplicationGroupIdSuffix</b>
	// represents the name of the Global Datastore, which is what you use to associate
	// a secondary cluster.</p> </li> </ul>
	GlobalReplicationGroup *types.GlobalReplicationGroup

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

type CreateReplicationGroupInput struct {
	// 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
	// The name of the cache engine to be used for the clusters in this replication
	// group.
	Engine *string
	// The daily time range (in UTC) during which ElastiCache begins taking a daily
	// snapshot of your node group (shard). Example: 05:00-09:00 If you do not specify
	// this parameter, ElastiCache automatically chooses an appropriate time range.
	SnapshotWindow *string
	// 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
	// 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 port number on which each member of the replication group accepts
	// connections.
	Port *int32
	// 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
	// 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
	// The name of the Global Datastore
	GlobalReplicationGroupId *string
	// Specifies whether a read-only replica is automatically promoted to read/write
	// primary if the existing primary fails.  <p>
	// <code>AutomaticFailoverEnabled</code> must be enabled for Redis (cluster mode
	// enabled) replication groups.</p> <p>Default: false</p>
	AutomaticFailoverEnabled *bool
	// 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
	// A user-created description for the replication group.
	ReplicationGroupDescription *string
	// 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
	// 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.  <p> <b>Important:</b> You can upgrade to
	// a newer engine version (see <a
	// href="https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/SelectEngine.html#VersionManagement">Selecting
	// a Cache Engine and Version</a>) in the <i>ElastiCache User Guide</i>, 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. </p>
	EngineVersion *string
	// 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:  <p> <b>M5 node types:</b>
	// <code>cache.m5.large</code>, <code>cache.m5.xlarge</code>,
	// <code>cache.m5.2xlarge</code>, <code>cache.m5.4xlarge</code>,
	// <code>cache.m5.12xlarge</code>, <code>cache.m5.24xlarge</code> </p> <p> <b>M4
	// node types:</b> <code>cache.m4.large</code>, <code>cache.m4.xlarge</code>,
	// <code>cache.m4.2xlarge</code>, <code>cache.m4.4xlarge</code>,
	// <code>cache.m4.10xlarge</code> </p> <p> <b>T3 node types:</b>
	// <code>cache.t3.micro</code>, <code>cache.t3.small</code>,
	// <code>cache.t3.medium</code> </p> <p> <b>T2 node types:</b>
	// <code>cache.t2.micro</code>, <code>cache.t2.small</code>,
	// <code>cache.t2.medium</code> </p> </li> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>T1 node types:</b> <code>cache.t1.micro</code> </p> <p>
	// <b>M1 node types:</b> <code>cache.m1.small</code>, <code>cache.m1.medium</code>,
	// <code>cache.m1.large</code>, <code>cache.m1.xlarge</code> </p> <p> <b>M3 node
	// types:</b> <code>cache.m3.medium</code>, <code>cache.m3.large</code>,
	// <code>cache.m3.xlarge</code>, <code>cache.m3.2xlarge</code> </p> </li> </ul>
	// </li> <li> <p>Compute optimized:</p> <ul> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>C1 node types:</b> <code>cache.c1.xlarge</code> </p>
	// </li> </ul> </li> <li> <p>Memory optimized:</p> <ul> <li> <p>Current generation:
	// </p> <p> <b>R5 node types:</b> <code>cache.r5.large</code>,
	// <code>cache.r5.xlarge</code>, <code>cache.r5.2xlarge</code>,
	// <code>cache.r5.4xlarge</code>, <code>cache.r5.12xlarge</code>,
	// <code>cache.r5.24xlarge</code> </p> <p> <b>R4 node types:</b>
	// <code>cache.r4.large</code>, <code>cache.r4.xlarge</code>,
	// <code>cache.r4.2xlarge</code>, <code>cache.r4.4xlarge</code>,
	// <code>cache.r4.8xlarge</code>, <code>cache.r4.16xlarge</code> </p> </li> <li>
	// <p>Previous generation: (not recommended)</p> <p> <b>M2 node types:</b>
	// <code>cache.m2.xlarge</code>, <code>cache.m2.2xlarge</code>,
	// <code>cache.m2.4xlarge</code> </p> <p> <b>R3 node types:</b>
	// <code>cache.r3.large</code>, <code>cache.r3.xlarge</code>,
	// <code>cache.r3.2xlarge</code>, <code>cache.r3.4xlarge</code>,
	// <code>cache.r3.8xlarge</code> </p> </li> </ul> </li> </ul> <p> <b>Additional
	// node type info</b> </p> <ul> <li> <p>All current generation instance types are
	// created in Amazon VPC by default.</p> </li> <li> <p>Redis append-only files
	// (AOF) are not supported for T1 or T2 instances.</p> </li> <li> <p>Redis Multi-AZ
	// with automatic failover is not supported on T1 instances.</p> </li> <li>
	// <p>Redis configuration variables <code>appendonly</code> and
	// <code>appendfsync</code> are not supported on Redis version 2.8.22 and
	// later.</p> </li> </ul>
	CacheNodeType *string
	// The 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
	// An optional parameter that specifies the number of replica nodes in each node
	// group (shard). Valid values are 0 to 5.
	ReplicasPerNodeGroup *int32
	// 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
	// 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
	// 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
	// A list of cache security group names to associate with this replication group.
	CacheSecurityGroupNames []*string
	// 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 ID of the KMS key used to encrypt the disk in the cluster.
	KmsKeyId *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 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
	// 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
	// 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
	// The replication group identifier. This parameter is stored as a lowercase
	// string.  <p>Constraints:</p> <ul> <li> <p>A name must contain from 1 to 40
	// alphanumeric characters or hyphens.</p> </li> <li> <p>The first character must
	// be a letter.</p> </li> <li> <p>A name cannot end with a hyphen or contain two
	// consecutive hyphens.</p> </li> </ul>
	ReplicationGroupId *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:  <p>Specifies the weekly time range during which maintenance  on
	// the cluster is performed. It is specified as a range in the format
	// ddd:hh24:mi-ddd:hh24:mi (24H Clock UTC). The minimum maintenance window is a 60
	// minute period. Valid values for ddd are:
	//
	//     * sun
	//
	//     * mon
	//
	//     * tue
	//
	//     *
	// wed
	//
	//     * thu
	//
	//     * fri
	//
	//     * sat
	//
	// Example: sun:23:00-mon:01:30
	PreferredMaintenanceWindow *string
	// This parameter is currently disabled.
	AutoMinorVersionUpgrade *bool
}

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 {
	// The identifier of an existing cluster. The snapshot is created from this
	// cluster.
	CacheClusterId *string
	// A name for the snapshot being created.
	SnapshotName *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 {
	// 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. </p>
	GlobalNodeGroupsToRemove []*string
	// The name of the Global Datastore
	GlobalReplicationGroupId *string
	// Indicates that the shard reconfiguration process begins immediately. At present,
	// the only permitted value for this parameter is true.
	ApplyImmediately *bool
	// The number of node groups (shards) that results from the modification of the
	// shard configuration
	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. </p>
	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.  <ul> <li> <p>The <b>GlobalReplicationGroupIdSuffix</b>
	// represents the name of the Global Datastore, which is what you use to associate
	// a secondary cluster.</p> </li> </ul>
	GlobalReplicationGroup *types.GlobalReplicationGroup

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

type DecreaseReplicaCountInput struct {
	// A list of the node ids to remove from the replication group or node group
	// (shard).
	ReplicasToRemove []*string
	// If True, the number of replica nodes is decreased immediately.
	// <code>ApplyImmediately=False</code> is not currently supported.</p>
	ApplyImmediately *bool
	// 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
	// The id of the replication group from which you want to remove replica nodes.
	ReplicationGroupId *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 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
	// The cluster identifier for the cluster to be deleted. This parameter is not case
	// sensitive.
	CacheClusterId *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.
	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.
	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.
	CacheSubnetGroupName *string
}

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

type DeleteGlobalReplicationGroupInput struct {
	// The name of the Global Datastore
	GlobalReplicationGroupId *string
	// The primary replication group is retained as a standalone replication group.
	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.  <ul> <li> <p>The <b>GlobalReplicationGroupIdSuffix</b>
	// represents the name of the Global Datastore, which is what you use to associate
	// a secondary cluster.</p> </li> </ul>
	GlobalReplicationGroup *types.GlobalReplicationGroup

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

type DeleteReplicationGroupInput struct {
	// If set to true, all of the read replicas are deleted, but the primary node is
	// retained.
	RetainPrimaryCluster *bool
	// The identifier for the cluster to be deleted. This parameter is not case
	// sensitive.
	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
}

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.
	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 {
	// An optional flag that can be included in the DescribeCacheCluster request to
	// retrieve information about the individual cache nodes.
	ShowCacheNodeInfo *bool
	// 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
	// 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.  <p>Default: 100</p>
	// <p>Constraints: minimum 20; maximum 100.</p>
	MaxRecords *int32
	// 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 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
}

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 cache engine version to return. Example: 1.4.14
	EngineVersion *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
	// 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 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
	// 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.  <p>Default: 100</p>
	// <p>Constraints: minimum 20; maximum 100.</p>
	MaxRecords *int32
}

type DescribeCacheEngineVersionsOutput struct {
	// Provides an identifier to allow retrieval of paginated results.
	Marker *string
	// A list of cache engine version details. Each element in the list contains
	// detailed information about one cache engine version.
	CacheEngineVersions []*types.CacheEngineVersion

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

type DescribeCacheParameterGroupsInput struct {
	// 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.  <p>Default: 100</p>
	// <p>Constraints: minimum 20; maximum 100.</p>
	MaxRecords *int32
	// 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 name of a specific cache parameter group to return details for.
	CacheParameterGroupName *string
}

type DescribeCacheParameterGroupsOutput struct {
	// Provides an identifier to allow retrieval of paginated results.
	Marker *string
	// A list of cache parameter groups. Each element in the list contains detailed
	// information about one cache parameter group.
	CacheParameterGroups []*types.CacheParameterGroup

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

type DescribeCacheParametersInput struct {
	// 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.  <p>Default: 100</p>
	// <p>Constraints: minimum 20; maximum 100.</p>
	MaxRecords *int32
	// The parameter types to return. Valid values: user | system | engine-default
	Source *string
	// 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
}

type DescribeCacheParametersOutput struct {
	// A list of Parameter () instances.
	Parameters []*types.Parameter
	// Provides an identifier to allow retrieval of paginated results.
	Marker *string
	// A list of parameters specific to a particular cache node type. Each element in
	// the list contains detailed information about one parameter.
	CacheNodeTypeSpecificParameters []*types.CacheNodeTypeSpecificParameter

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

type DescribeCacheSecurityGroupsInput struct {
	// 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.  <p>Default: 100</p>
	// <p>Constraints: minimum 20; maximum 100.</p>
	MaxRecords *int32
	// 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 name of the cache security group to return details for.
	CacheSecurityGroupName *string
}

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 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.  <p>Default: 100</p>
	// <p>Constraints: minimum 20; maximum 100.</p>
	MaxRecords *int32
	// 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 name of the cache subnet group to return details for.
	CacheSubnetGroupName *string
}

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 |
	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.  <p>Default: 100</p>
	// <p>Constraints: minimum 20; maximum 100.</p>
	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 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
	// 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.  <p>Default: 100</p>
	// <p>Constraints: minimum 20; maximum 100.</p>
	MaxRecords *int32
	// 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 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
	// The identifier of the event source for which events are returned. If not
	// specified, all sources are included in the response.
	SourceIdentifier *string
	// The number of minutes worth of events to retrieve.
	Duration *int32
}

type DescribeEventsOutput struct {
	// Provides an identifier to allow retrieval of paginated results.
	Marker *string
	// A list of events. Each element in the list contains detailed information about
	// one event.
	Events []*types.Event

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

type DescribeGlobalReplicationGroupsInput struct {
	// 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
	// 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
}

type DescribeGlobalReplicationGroupsOutput 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
	// Indicates the slot configuration and global identifier for each slice group.
	GlobalReplicationGroups []*types.GlobalReplicationGroup

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

type DescribeReplicationGroupsInput struct {
	// 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
	// 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.  <p>Default: 100</p>
	// <p>Constraints: minimum 20; maximum 100.</p>
	MaxRecords *int32
	// 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
}

type DescribeReplicationGroupsOutput struct {
	// A list of replication groups. Each item in the list contains detailed
	// information about one replication group.
	ReplicationGroups []*types.ReplicationGroup
	// Provides an identifier to allow retrieval of paginated results.
	Marker *string

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

type DescribeReservedCacheNodesInput struct {
	// 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.  <p>Default: 100</p>
	// <p>Constraints: minimum 20; maximum 100.</p>
	MaxRecords *int32
	// The offering identifier filter value. Use this parameter to show only purchased
	// reservations matching the specified offering identifier.
	ReservedCacheNodesOfferingId *string
	// 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 reserved cache node identifier filter value. Use this parameter to show only
	// the reservation that matches the specified reservation ID.
	ReservedCacheNodeId *string
	// The product description filter value. Use this parameter to show only those
	// reservations matching the specified product description.
	ProductDescription *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
	// The cache node type filter value. Use this parameter to show only those
	// reservations matching the specified cache node type.  <p>The following node
	// types are supported by ElastiCache. Generally speaking, the current generation
	// types provide more memory and computational power at lower cost when compared to
	// their equivalent previous generation counterparts.</p> <ul> <li> <p>General
	// purpose:</p> <ul> <li> <p>Current generation: </p> <p> <b>M5 node types:</b>
	// <code>cache.m5.large</code>, <code>cache.m5.xlarge</code>,
	// <code>cache.m5.2xlarge</code>, <code>cache.m5.4xlarge</code>,
	// <code>cache.m5.12xlarge</code>, <code>cache.m5.24xlarge</code> </p> <p> <b>M4
	// node types:</b> <code>cache.m4.large</code>, <code>cache.m4.xlarge</code>,
	// <code>cache.m4.2xlarge</code>, <code>cache.m4.4xlarge</code>,
	// <code>cache.m4.10xlarge</code> </p> <p> <b>T3 node types:</b>
	// <code>cache.t3.micro</code>, <code>cache.t3.small</code>,
	// <code>cache.t3.medium</code> </p> <p> <b>T2 node types:</b>
	// <code>cache.t2.micro</code>, <code>cache.t2.small</code>,
	// <code>cache.t2.medium</code> </p> </li> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>T1 node types:</b> <code>cache.t1.micro</code> </p> <p>
	// <b>M1 node types:</b> <code>cache.m1.small</code>, <code>cache.m1.medium</code>,
	// <code>cache.m1.large</code>, <code>cache.m1.xlarge</code> </p> <p> <b>M3 node
	// types:</b> <code>cache.m3.medium</code>, <code>cache.m3.large</code>,
	// <code>cache.m3.xlarge</code>, <code>cache.m3.2xlarge</code> </p> </li> </ul>
	// </li> <li> <p>Compute optimized:</p> <ul> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>C1 node types:</b> <code>cache.c1.xlarge</code> </p>
	// </li> </ul> </li> <li> <p>Memory optimized:</p> <ul> <li> <p>Current generation:
	// </p> <p> <b>R5 node types:</b> <code>cache.r5.large</code>,
	// <code>cache.r5.xlarge</code>, <code>cache.r5.2xlarge</code>,
	// <code>cache.r5.4xlarge</code>, <code>cache.r5.12xlarge</code>,
	// <code>cache.r5.24xlarge</code> </p> <p> <b>R4 node types:</b>
	// <code>cache.r4.large</code>, <code>cache.r4.xlarge</code>,
	// <code>cache.r4.2xlarge</code>, <code>cache.r4.4xlarge</code>,
	// <code>cache.r4.8xlarge</code>, <code>cache.r4.16xlarge</code> </p> </li> <li>
	// <p>Previous generation: (not recommended)</p> <p> <b>M2 node types:</b>
	// <code>cache.m2.xlarge</code>, <code>cache.m2.2xlarge</code>,
	// <code>cache.m2.4xlarge</code> </p> <p> <b>R3 node types:</b>
	// <code>cache.r3.large</code>, <code>cache.r3.xlarge</code>,
	// <code>cache.r3.2xlarge</code>, <code>cache.r3.4xlarge</code>,
	// <code>cache.r3.8xlarge</code> </p> </li> </ul> </li> </ul> <p> <b>Additional
	// node type info</b> </p> <ul> <li> <p>All current generation instance types are
	// created in Amazon VPC by default.</p> </li> <li> <p>Redis append-only files
	// (AOF) are not supported for T1 or T2 instances.</p> </li> <li> <p>Redis Multi-AZ
	// with automatic failover is not supported on T1 instances.</p> </li> <li>
	// <p>Redis configuration variables <code>appendonly</code> and
	// <code>appendfsync</code> are not supported on Redis version 2.8.22 and
	// later.</p> </li> </ul>
	CacheNodeType *string
	// 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
}

type DescribeReservedCacheNodesOfferingsInput struct {
	// The cache node type filter value. Use this parameter to show only the available
	// offerings matching the specified cache node type.  <p>The following node types
	// are supported by ElastiCache. Generally speaking, the current generation types
	// provide more memory and computational power at lower cost when compared to their
	// equivalent previous generation counterparts.</p> <ul> <li> <p>General
	// purpose:</p> <ul> <li> <p>Current generation: </p> <p> <b>M5 node types:</b>
	// <code>cache.m5.large</code>, <code>cache.m5.xlarge</code>,
	// <code>cache.m5.2xlarge</code>, <code>cache.m5.4xlarge</code>,
	// <code>cache.m5.12xlarge</code>, <code>cache.m5.24xlarge</code> </p> <p> <b>M4
	// node types:</b> <code>cache.m4.large</code>, <code>cache.m4.xlarge</code>,
	// <code>cache.m4.2xlarge</code>, <code>cache.m4.4xlarge</code>,
	// <code>cache.m4.10xlarge</code> </p> <p> <b>T3 node types:</b>
	// <code>cache.t3.micro</code>, <code>cache.t3.small</code>,
	// <code>cache.t3.medium</code> </p> <p> <b>T2 node types:</b>
	// <code>cache.t2.micro</code>, <code>cache.t2.small</code>,
	// <code>cache.t2.medium</code> </p> </li> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>T1 node types:</b> <code>cache.t1.micro</code> </p> <p>
	// <b>M1 node types:</b> <code>cache.m1.small</code>, <code>cache.m1.medium</code>,
	// <code>cache.m1.large</code>, <code>cache.m1.xlarge</code> </p> <p> <b>M3 node
	// types:</b> <code>cache.m3.medium</code>, <code>cache.m3.large</code>,
	// <code>cache.m3.xlarge</code>, <code>cache.m3.2xlarge</code> </p> </li> </ul>
	// </li> <li> <p>Compute optimized:</p> <ul> <li> <p>Previous generation: (not
	// recommended)</p> <p> <b>C1 node types:</b> <code>cache.c1.xlarge</code> </p>
	// </li> </ul> </li> <li> <p>Memory optimized:</p> <ul> <li> <p>Current generation:
	// </p> <p> <b>R5 node types:</b> <code>cache.r5.large</code>,
	// <code>cache.r5.xlarge</code>, <code>cache.r5.2xlarge</code>,
	// <code>cache.r5.4xlarge</code>, <code>cache.r5.12xlarge</code>,
	// <code>cache.r5.24xlarge</code> </p> <p> <b>R4 node types:</b>
	// <code>cache.r4.large</code>, <code>cache.r4.xlarge</code>,
	// <code>cache.r4.2xlarge</code>, <code>cache.r4.4xlarge</code>,
	// <code>cache.r4.8xlarge</code>, <code>cache.r4.16xlarge</code> </p> </li> <li>
	// <p>Previous generation: (not recommended)</p> <p> <b>M2 node types:</b>
	// <code>cache.m2.xlarge</code>, <code>cache.m2.2xlarge</code>,
	// <code>cache.m2.4xlarge</code> </p> <p> <b>R3 node types:</b>
	// <code>cache.r3.large</code>, <code>cache.r3.xlarge</code>,
	// <code>cache.r3.2xlarge</code>, <code>cache.r3.4xlarge</code>,
	// <code>cache.r3.8xlarge</code> </p> </li> </ul> </li> </ul> <p> <b>Additional
	// node type info</b> </p> <ul> <li> <p>All current generation instance types are
	// created in Amazon VPC by default.</p> </li> <li> <p>Redis append-only files
	// (AOF) are not supported for T1 or T2 instances.</p> </li> <li> <p>Redis Multi-AZ
	// with automatic failover is not supported on T1 instances.</p> </li> <li>
	// <p>Redis configuration variables <code>appendonly</code> and
	// <code>appendfsync</code> are not supported on Redis version 2.8.22 and
	// later.</p> </li> </ul>
	CacheNodeType *string
	// The offering type 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 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
	// 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
	// The product description filter value. Use this parameter to show only the
	// available offerings matching the specified product description.
	ProductDescription *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.  <p>Default: 100</p>
	// <p>Constraints: minimum 20; maximum 100.</p>
	MaxRecords *int32
}

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 {
	// A list of reserved cache nodes. Each element in the list contains detailed
	// information about one node.
	ReservedCacheNodes []*types.ReservedCacheNode
	// Provides an identifier to allow retrieval of paginated results.
	Marker *string

	// 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 status of the service update
	ServiceUpdateStatus []types.ServiceUpdateStatus
	// The maximum number of records to include in the response
	MaxRecords *int32
	// The unique ID of the service update
	ServiceUpdateName *string
}

type DescribeServiceUpdatesOutput struct {
	// A list of service updates
	ServiceUpdates []*types.ServiceUpdate
	// 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 DescribeSnapshotsInput struct {
	// A Boolean value which if true, the node group (shard) configuration is included
	// in the snapshot description.
	ShowNodeGroupConfig *bool
	// A user-supplied replication group identifier. If this parameter is specified,
	// only snapshots associated with that specific replication group are described.
	ReplicationGroupId *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
	// 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 user-supplied cluster identifier. If this parameter is specified, only
	// snapshots associated with that specific cluster are described.
	CacheClusterId *string
	// A user-supplied name of the snapshot. If this parameter is specified, only this
	// snapshot are described.
	SnapshotName *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
}

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 {
	// Dictates whether to include node level update status in the response
	ShowNodeLevelUpdateStatus *bool
	// The Elasticache engine to which the update applies. Either Redis or Memcached
	Engine *string
	// The status of the update action.
	UpdateActionStatus []types.UpdateActionStatus
	// The cache cluster IDs
	CacheClusterIds []*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 status of the service update
	ServiceUpdateStatus []types.ServiceUpdateStatus
	// 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 range of time specified to search for service updates that are in available
	// status
	ServiceUpdateTimeRange *types.TimeRangeFilter
}

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 secondary cluster you wish to remove from the Global Datastore
	ReplicationGroupId *string
	// The AWS region of secondary cluster you wish to remove from the Global Datastore
	ReplicationGroupRegion *string
	// The name of the Global Datastore
	GlobalReplicationGroupId *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.  <ul> <li> <p>The <b>GlobalReplicationGroupIdSuffix</b>
	// represents the name of the Global Datastore, which is what you use to associate
	// a secondary cluster.</p> </li> </ul>
	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 primary replication group
	PrimaryReplicationGroupId *string
	// The name of the Global Datastore
	GlobalReplicationGroupId *string
	// The AWS region of the primary cluster of the Global Datastore
	PrimaryRegion *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.  <ul> <li> <p>The <b>GlobalReplicationGroupIdSuffix</b>
	// represents the name of the Global Datastore, which is what you use to associate
	// a secondary cluster.</p> </li> </ul>
	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 {
	// The number of node groups you wish to add
	NodeGroupCount *int32
	// Indicates that the process begins immediately. At present, the only permitted
	// value for this parameter is true.
	ApplyImmediately *bool
	// 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
	// The name of the Global Datastore
	GlobalReplicationGroupId *string
}

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.  <ul> <li> <p>The <b>GlobalReplicationGroupIdSuffix</b>
	// represents the name of the Global Datastore, which is what you use to associate
	// a secondary cluster.</p> </li> </ul>
	GlobalReplicationGroup *types.GlobalReplicationGroup

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

type IncreaseReplicaCountInput struct {
	// 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
	// The id of the replication group to which you want to add replica nodes.
	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
	// If True, the number of replica nodes is increased immediately.
	// <code>ApplyImmediately=False</code> is not currently supported.</p>
	ApplyImmediately *bool
}

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 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.  <important> <p>You must provide a value for either
	// the <code>CacheClusterId</code> or the <code>ReplicationGroupId</code>.</p>
	// </important>
	ReplicationGroupId *string
	// 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.
	// <important> <p>You must provide a value for either the
	// <code>CacheClusterId</code> or the <code>ReplicationGroupId</code>.</p>
	// </important>
	CacheClusterId *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 up a Redis cluster
	// or replication group using ModifyCacheCluster or ModifyReplicationGroup, use a
	// value from this list for the CacheNodeType parameter.
	ScaleUpModifications []*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 down a Redis
	// cluster or replication group using ModifyCacheCluster or ModifyReplicationGroup,
	// use a value from this list for the CacheNodeType parameter. </p>
	ScaleDownModifications []*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).
	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 upgraded version of the cache engine to be run on the cache nodes.  <p>
	// <b>Important:</b> You can upgrade to a newer engine version (see <a
	// href="https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/SelectEngine.html#VersionManagement">Selecting
	// a Cache Engine and Version</a>), 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. </p>
	EngineVersion *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
	// 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
	// This parameter is currently disabled.
	AutoMinorVersionUpgrade *bool
	// 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
	// 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 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.
	//
	//     <p>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 <code>NumCacheNodes</code> to the number of current
	// nodes.</p> <p>If <code>cross-az</code> 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 <b>Availability Zone
	// Considerations</b> section of <a
	// href="https://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/CacheNodes.SupportedTypes.html">Cache
	// Node Considerations for Memcached</a>.</p> <p> <b>Impact of new add/remove
	// requests upon pending requests</b> </p> <ul> <li> <p>Scenario-1</p> <ul> <li>
	// <p>Pending Action: Delete</p> </li> <li> <p>New Request: Delete</p> </li> <li>
	// <p>Result: The new delete, pending or immediate, replaces the pending
	// delete.</p> </li> </ul> </li> <li> <p>Scenario-2</p> <ul> <li> <p>Pending
	// Action: Delete</p> </li> <li> <p>New Request: Create</p> </li> <li> <p>Result:
	// The new create, pending or immediate, replaces the pending delete.</p> </li>
	// </ul> </li> <li> <p>Scenario-3</p> <ul> <li> <p>Pending Action: Create</p> </li>
	// <li> <p>New Request: Delete</p> </li> <li> <p>Result: The new delete, pending or
	// immediate, replaces the pending create.</p> </li> </ul> </li> <li>
	// <p>Scenario-4</p> <ul> <li> <p>Pending Action: Create</p> </li> <li> <p>New
	// Request: Create</p> </li> <li> <p>Result: The new create is added to the pending
	// create.</p> <important> <p> <b>Important:</b> If the new create request is
	// <b>Apply Immediately - Yes</b>, all creates are performed immediately. If the
	// new create request is <b>Apply Immediately - No</b>, all creates are
	// pending.</p> </important> </li> </ul> </li> </ul>
	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
	// 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 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.  <note> <p>Adding or
	// removing Memcached cache nodes can be applied immediately or as a pending
	// operation (see <code>ApplyImmediately</code>).</p> <p>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
	// <code>ModifyCacheCluster</code> request and set <code>NumCacheNodes</code> equal
	// to the number of cache nodes currently in the cluster.</p> </note>
	NumCacheNodes *int32
	// 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 cluster identifier. This value is stored as a lowercase string.
	CacheClusterId *string
	// The daily time range (in UTC) during which ElastiCache begins taking a daily
	// snapshot of your cluster.
	SnapshotWindow *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 status of the Amazon SNS notification topic. Notifications are sent only if
	// the status is active. Valid values: active | inactive
	NotificationTopicStatus *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
	// 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 <a
	// href="http://redis.io/commands/AUTH">AUTH</a>.</p>
	AuthToken *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
}

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 {
	// 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.
	ParameterNameValues []*types.ParameterNameValue
	// The name of the cache parameter group to modify.
	CacheParameterGroupName *string
}

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
	CacheSubnetGroupName *string
	// The EC2 subnet IDs for the cache subnet group.
	SubnetIds []*string
	// A description of the cache subnet group.
	CacheSubnetGroupDescription *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 {
	// 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
	// The name of the Global Datastore
	GlobalReplicationGroupId *string
	// A description of the Global Datastore
	GlobalReplicationGroupDescription *string
	// 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.
	ApplyImmediately *bool
	// Determines whether a read replica is automatically promoted to read/write
	// primary if the existing primary encounters a failure.
	AutomaticFailoverEnabled *bool
}

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.  <ul> <li> <p>The <b>GlobalReplicationGroupIdSuffix</b>
	// represents the name of the Global Datastore, which is what you use to associate
	// a secondary cluster.</p> </li> </ul>
	GlobalReplicationGroup *types.GlobalReplicationGroup

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

type ModifyReplicationGroupInput struct {
	// 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 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
	// 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 valid cache node type that you want to scale this replication group to.
	CacheNodeType *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
	// 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 <a
	// href="http://redis.io/commands/AUTH">AUTH</a>.</p>
	AuthToken *string
	// 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
	// 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 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
	// 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 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
	// 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
	// The upgraded version of the cache engine to be run on the clusters in the
	// replication group.  <p> <b>Important:</b> You can upgrade to a newer engine
	// version (see <a
	// href="https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/SelectEngine.html#VersionManagement">Selecting
	// a Cache Engine and Version</a>), 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.
	// </p>
	EngineVersion *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
	// 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
	// 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
	// Deprecated. This parameter is not used.
	NodeGroupId *string
	// The identifier of the replication group to modify.
	ReplicationGroupId *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
}

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 {
	// 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
	// Indicates that the shard reconfiguration process begins immediately. At present,
	// the only permitted value for this parameter is true. Value: true
	ApplyImmediately *bool
	// 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
	// The number of node groups (shards) that results from the modification of the
	// shard configuration.
	NodeGroupCount *int32
	// The name of the Redis (cluster mode enabled) cluster (replication group) on
	// which the shards are to be configured.
	ReplicationGroupId *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
	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 {
	// The name of the Global Datastore
	GlobalReplicationGroupId *string
	// If True, redistribution is applied immediately.
	ApplyImmediately *bool
}

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.  <ul> <li> <p>The <b>GlobalReplicationGroupIdSuffix</b>
	// represents the name of the Global Datastore, which is what you use to associate
	// a secondary cluster.</p> </li> </ul>
	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.
	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.
	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).
	ResourceName *string
	// A list of TagKeys identifying the tags you want removed from the named resource.
	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.
	CacheParameterGroupName *string
	// 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
	// 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
}

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 ResolveEndpointMiddlewareOptions interface {
	GetEndpointResolver() EndpointResolver
	GetEndpointOptions() ResolverOptions
}

type ResolverOptions = internalendpoints.Options

type RevokeCacheSecurityGroupIngressInput struct {
	// The name of the cache security group to revoke ingress from.
	CacheSecurityGroupName *string
	// The name of the Amazon EC2 security group to revoke access from.
	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.
	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.
	CustomerNodeEndpointList []*types.CustomerNodeEndpoint
	// The ID of the replication group to which data should be migrated.
	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.
	NodeGroupId *string
	// The name of the replication group (console: cluster) whose automatic failover is
	// being tested by this operation.
	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
}