@aws-sdk/client-elasticache 3.35.0 → 3.38.0

package/dist-types/ts3.4/commands/FailoverGlobalReplicationGroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface FailoverGlobalReplicationGroupCommandInput extends FailoverGlob
 }
 export interface FailoverGlobalReplicationGroupCommandOutput extends FailoverGlobalReplicationGroupResult, __MetadataBearer {
 }
-/**
- * <p>Used to failover the primary region to a selected secondary region. The selected secondary region will become primary, and all other clusters will become secondary.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, FailoverGlobalReplicationGroupCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, FailoverGlobalReplicationGroupCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new FailoverGlobalReplicationGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link FailoverGlobalReplicationGroupCommandInput} for command's `input` shape.
- * @see {@link FailoverGlobalReplicationGroupCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class FailoverGlobalReplicationGroupCommand extends $Command<FailoverGlobalReplicationGroupCommandInput, FailoverGlobalReplicationGroupCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: FailoverGlobalReplicationGroupCommandInput;
     constructor(input: FailoverGlobalReplicationGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<FailoverGlobalReplicationGroupCommandInput, FailoverGlobalReplicationGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/IncreaseNodeGroupsInGlobalReplicationGroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface IncreaseNodeGroupsInGlobalReplicationGroupCommandInput extends
 }
 export interface IncreaseNodeGroupsInGlobalReplicationGroupCommandOutput extends IncreaseNodeGroupsInGlobalReplicationGroupResult, __MetadataBearer {
 }
-/**
- * <p>Increase the number of node groups in the Global datastore</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, IncreaseNodeGroupsInGlobalReplicationGroupCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, IncreaseNodeGroupsInGlobalReplicationGroupCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new IncreaseNodeGroupsInGlobalReplicationGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link IncreaseNodeGroupsInGlobalReplicationGroupCommandInput} for command's `input` shape.
- * @see {@link IncreaseNodeGroupsInGlobalReplicationGroupCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class IncreaseNodeGroupsInGlobalReplicationGroupCommand extends $Command<IncreaseNodeGroupsInGlobalReplicationGroupCommandInput, IncreaseNodeGroupsInGlobalReplicationGroupCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: IncreaseNodeGroupsInGlobalReplicationGroupCommandInput;
     constructor(input: IncreaseNodeGroupsInGlobalReplicationGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<IncreaseNodeGroupsInGlobalReplicationGroupCommandInput, IncreaseNodeGroupsInGlobalReplicationGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/IncreaseReplicaCountCommand.d.ts

@@ -6,31 +6,11 @@ export interface IncreaseReplicaCountCommandInput extends IncreaseReplicaCountMe
 }
 export interface IncreaseReplicaCountCommandOutput extends IncreaseReplicaCountResult, __MetadataBearer {
 }
-/**
- * <p>Dynamically increases the number of replicas in a Redis (cluster mode disabled) replication group or the number of
- *             replica nodes in one or more node groups (shards) of a Redis (cluster mode enabled) replication group. This operation
- *             is performed with no cluster down time.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, IncreaseReplicaCountCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, IncreaseReplicaCountCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new IncreaseReplicaCountCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link IncreaseReplicaCountCommandInput} for command's `input` shape.
- * @see {@link IncreaseReplicaCountCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class IncreaseReplicaCountCommand extends $Command<IncreaseReplicaCountCommandInput, IncreaseReplicaCountCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: IncreaseReplicaCountCommandInput;
     constructor(input: IncreaseReplicaCountCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<IncreaseReplicaCountCommandInput, IncreaseReplicaCountCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListAllowedNodeTypeModificationsCommand.d.ts

@@ -6,34 +6,11 @@ export interface ListAllowedNodeTypeModificationsCommandInput extends ListAllowe
 }
 export interface ListAllowedNodeTypeModificationsCommandOutput extends AllowedNodeTypeModificationsMessage, __MetadataBearer {
 }
-/**
- * <p>Lists all available node types that you
- *             can scale your Redis cluster's or replication group's current node type.</p>
- *
- *         <p>When you use the <code>ModifyCacheCluster</code> or <code>ModifyReplicationGroup</code> operations to
- *             scale your cluster or replication group, the value of the <code>CacheNodeType</code> parameter
- *             must be one of the node types returned by this operation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, ListAllowedNodeTypeModificationsCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, ListAllowedNodeTypeModificationsCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new ListAllowedNodeTypeModificationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListAllowedNodeTypeModificationsCommandInput} for command's `input` shape.
- * @see {@link ListAllowedNodeTypeModificationsCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListAllowedNodeTypeModificationsCommand extends $Command<ListAllowedNodeTypeModificationsCommandInput, ListAllowedNodeTypeModificationsCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: ListAllowedNodeTypeModificationsCommandInput;
     constructor(input: ListAllowedNodeTypeModificationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAllowedNodeTypeModificationsCommandInput, ListAllowedNodeTypeModificationsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListTagsForResourceCommand.d.ts

@@ -6,35 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceMess
 }
 export interface ListTagsForResourceCommandOutput extends TagListMessage, __MetadataBearer {
 }
-/**
- * <p>Lists all tags currently on a  named resource.</p>
- *          <p>    A  tag is a key-value pair where the key and value are case-sensitive.
- *             You can use tags to categorize and track all your ElastiCache resources, with the exception of global replication group. When you add or remove tags on replication groups, those actions will be replicated to all nodes in the replication group.
- *      For more information, see <a href="http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/IAM.ResourceLevelPermissions.html">Resource-level permissions</a>.</p>
- *
- *         <p>If the cluster is not in the <i>available</i> state, <code>ListTagsForResource</code>
- *             returns an error.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, ListTagsForResourceCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, ListTagsForResourceCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ModifyCacheClusterCommand.d.ts

@@ -6,31 +6,11 @@ export interface ModifyCacheClusterCommandInput extends ModifyCacheClusterMessag
 }
 export interface ModifyCacheClusterCommandOutput extends ModifyCacheClusterResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the settings for a cluster. You
- *             can use this operation to change one or more cluster configuration parameters by
- *             specifying the parameters and the new values.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, ModifyCacheClusterCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, ModifyCacheClusterCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new ModifyCacheClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyCacheClusterCommandInput} for command's `input` shape.
- * @see {@link ModifyCacheClusterCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyCacheClusterCommand extends $Command<ModifyCacheClusterCommandInput, ModifyCacheClusterCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: ModifyCacheClusterCommandInput;
     constructor(input: ModifyCacheClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyCacheClusterCommandInput, ModifyCacheClusterCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ModifyCacheParameterGroupCommand.d.ts

@@ -6,31 +6,11 @@ export interface ModifyCacheParameterGroupCommandInput extends ModifyCacheParame
 }
 export interface ModifyCacheParameterGroupCommandOutput extends CacheParameterGroupNameMessage, __MetadataBearer {
 }
-/**
- * <p>Modifies the parameters of a cache
- *             parameter group. You can modify up to 20 parameters in a single request by submitting a
- *             list parameter name and value pairs.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, ModifyCacheParameterGroupCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, ModifyCacheParameterGroupCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new ModifyCacheParameterGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyCacheParameterGroupCommandInput} for command's `input` shape.
- * @see {@link ModifyCacheParameterGroupCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyCacheParameterGroupCommand extends $Command<ModifyCacheParameterGroupCommandInput, ModifyCacheParameterGroupCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: ModifyCacheParameterGroupCommandInput;
     constructor(input: ModifyCacheParameterGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyCacheParameterGroupCommandInput, ModifyCacheParameterGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ModifyCacheSubnetGroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface ModifyCacheSubnetGroupCommandInput extends ModifyCacheSubnetGro
 }
 export interface ModifyCacheSubnetGroupCommandOutput extends ModifyCacheSubnetGroupResult, __MetadataBearer {
 }
-/**
- * <p>Modifies an existing cache subnet group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, ModifyCacheSubnetGroupCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, ModifyCacheSubnetGroupCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new ModifyCacheSubnetGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyCacheSubnetGroupCommandInput} for command's `input` shape.
- * @see {@link ModifyCacheSubnetGroupCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyCacheSubnetGroupCommand extends $Command<ModifyCacheSubnetGroupCommandInput, ModifyCacheSubnetGroupCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: ModifyCacheSubnetGroupCommandInput;
     constructor(input: ModifyCacheSubnetGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyCacheSubnetGroupCommandInput, ModifyCacheSubnetGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ModifyGlobalReplicationGroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface ModifyGlobalReplicationGroupCommandInput extends ModifyGlobalRe
 }
 export interface ModifyGlobalReplicationGroupCommandOutput extends ModifyGlobalReplicationGroupResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the settings for a Global datastore.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, ModifyGlobalReplicationGroupCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, ModifyGlobalReplicationGroupCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new ModifyGlobalReplicationGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyGlobalReplicationGroupCommandInput} for command's `input` shape.
- * @see {@link ModifyGlobalReplicationGroupCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyGlobalReplicationGroupCommand extends $Command<ModifyGlobalReplicationGroupCommandInput, ModifyGlobalReplicationGroupCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: ModifyGlobalReplicationGroupCommandInput;
     constructor(input: ModifyGlobalReplicationGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyGlobalReplicationGroupCommandInput, ModifyGlobalReplicationGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ModifyReplicationGroupCommand.d.ts

@@ -6,45 +6,11 @@ export interface ModifyReplicationGroupCommandInput extends ModifyReplicationGro
 }
 export interface ModifyReplicationGroupCommandOutput extends ModifyReplicationGroupResult, __MetadataBearer {
 }
-/**
- * <p>Modifies the settings for a replication group.</p>
- *
- *         <ul>
- *             <li>
- *                 <p>
- *                   <a href="https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/scaling-redis-cluster-mode-enabled.html">Scaling for Amazon ElastiCache for Redis (cluster mode enabled)</a>
- *                     in the ElastiCache User Guide</p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <a href="https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroupShardConfiguration.html">ModifyReplicationGroupShardConfiguration</a>
- *                     in the ElastiCache API Reference</p>
- *             </li>
- *          </ul>
- *         <note>
- *             <p>This operation is valid for Redis only.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, ModifyReplicationGroupCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, ModifyReplicationGroupCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new ModifyReplicationGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyReplicationGroupCommandInput} for command's `input` shape.
- * @see {@link ModifyReplicationGroupCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyReplicationGroupCommand extends $Command<ModifyReplicationGroupCommandInput, ModifyReplicationGroupCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: ModifyReplicationGroupCommandInput;
     constructor(input: ModifyReplicationGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyReplicationGroupCommandInput, ModifyReplicationGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ModifyReplicationGroupShardConfigurationCommand.d.ts

@@ -6,30 +6,11 @@ export interface ModifyReplicationGroupShardConfigurationCommandInput extends Mo
 }
 export interface ModifyReplicationGroupShardConfigurationCommandOutput extends ModifyReplicationGroupShardConfigurationResult, __MetadataBearer {
 }
-/**
- * <p>Modifies a replication group's shards (node groups) by allowing you to
- *             add shards, remove shards, or rebalance the keyspaces among existing shards.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, ModifyReplicationGroupShardConfigurationCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, ModifyReplicationGroupShardConfigurationCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new ModifyReplicationGroupShardConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyReplicationGroupShardConfigurationCommandInput} for command's `input` shape.
- * @see {@link ModifyReplicationGroupShardConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyReplicationGroupShardConfigurationCommand extends $Command<ModifyReplicationGroupShardConfigurationCommandInput, ModifyReplicationGroupShardConfigurationCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: ModifyReplicationGroupShardConfigurationCommandInput;
     constructor(input: ModifyReplicationGroupShardConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyReplicationGroupShardConfigurationCommandInput, ModifyReplicationGroupShardConfigurationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ModifyUserCommand.d.ts

@@ -6,29 +6,11 @@ export interface ModifyUserCommandInput extends ModifyUserMessage {
 }
 export interface ModifyUserCommandOutput extends User, __MetadataBearer {
 }
-/**
- * <p>Changes user password(s) and/or access string.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, ModifyUserCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, ModifyUserCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new ModifyUserCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyUserCommandInput} for command's `input` shape.
- * @see {@link ModifyUserCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyUserCommand extends $Command<ModifyUserCommandInput, ModifyUserCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: ModifyUserCommandInput;
     constructor(input: ModifyUserCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyUserCommandInput, ModifyUserCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ModifyUserGroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface ModifyUserGroupCommandInput extends ModifyUserGroupMessage {
 }
 export interface ModifyUserGroupCommandOutput extends UserGroup, __MetadataBearer {
 }
-/**
- * <p>Changes the list of users that belong to the user group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, ModifyUserGroupCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, ModifyUserGroupCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new ModifyUserGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyUserGroupCommandInput} for command's `input` shape.
- * @see {@link ModifyUserGroupCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyUserGroupCommand extends $Command<ModifyUserGroupCommandInput, ModifyUserGroupCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: ModifyUserGroupCommandInput;
     constructor(input: ModifyUserGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyUserGroupCommandInput, ModifyUserGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PurchaseReservedCacheNodesOfferingCommand.d.ts

@@ -6,32 +6,11 @@ export interface PurchaseReservedCacheNodesOfferingCommandInput extends Purchase
 }
 export interface PurchaseReservedCacheNodesOfferingCommandOutput extends PurchaseReservedCacheNodesOfferingResult, __MetadataBearer {
 }
-/**
- * <p>Allows you to purchase a reserved
- *             cache node offering. Reserved nodes are not eligible for cancellation and are non-refundable. For more information,
- *             see <a href="https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/reserved-nodes.html">Managing Costs with Reserved Nodes</a> for Redis or
- *             <a href="https://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/reserved-nodes.html">Managing Costs with Reserved Nodes</a> for Memcached.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, PurchaseReservedCacheNodesOfferingCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, PurchaseReservedCacheNodesOfferingCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new PurchaseReservedCacheNodesOfferingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PurchaseReservedCacheNodesOfferingCommandInput} for command's `input` shape.
- * @see {@link PurchaseReservedCacheNodesOfferingCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PurchaseReservedCacheNodesOfferingCommand extends $Command<PurchaseReservedCacheNodesOfferingCommandInput, PurchaseReservedCacheNodesOfferingCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: PurchaseReservedCacheNodesOfferingCommandInput;
     constructor(input: PurchaseReservedCacheNodesOfferingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PurchaseReservedCacheNodesOfferingCommandInput, PurchaseReservedCacheNodesOfferingCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/RebalanceSlotsInGlobalReplicationGroupCommand.d.ts

@@ -6,29 +6,11 @@ export interface RebalanceSlotsInGlobalReplicationGroupCommandInput extends Reba
 }
 export interface RebalanceSlotsInGlobalReplicationGroupCommandOutput extends RebalanceSlotsInGlobalReplicationGroupResult, __MetadataBearer {
 }
-/**
- * <p>Redistribute slots to ensure uniform distribution across existing shards in the cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, RebalanceSlotsInGlobalReplicationGroupCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, RebalanceSlotsInGlobalReplicationGroupCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new RebalanceSlotsInGlobalReplicationGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RebalanceSlotsInGlobalReplicationGroupCommandInput} for command's `input` shape.
- * @see {@link RebalanceSlotsInGlobalReplicationGroupCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RebalanceSlotsInGlobalReplicationGroupCommand extends $Command<RebalanceSlotsInGlobalReplicationGroupCommandInput, RebalanceSlotsInGlobalReplicationGroupCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: RebalanceSlotsInGlobalReplicationGroupCommandInput;
     constructor(input: RebalanceSlotsInGlobalReplicationGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RebalanceSlotsInGlobalReplicationGroupCommandInput, RebalanceSlotsInGlobalReplicationGroupCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/RebootCacheClusterCommand.d.ts

@@ -6,41 +6,11 @@ export interface RebootCacheClusterCommandInput extends RebootCacheClusterMessag
 }
 export interface RebootCacheClusterCommandOutput extends RebootCacheClusterResult, __MetadataBearer {
 }
-/**
- * <p>Reboots some, or all, of the cache nodes
- *             within a provisioned cluster. This operation applies any modified cache parameter
- *             groups to the cluster. The reboot operation takes place as soon as possible, and
- *             results in a momentary outage to the cluster. During the reboot, the cluster
- *             status is set to REBOOTING.</p>
- *         <p>The reboot causes the contents of the cache (for each cache node being rebooted) to be lost.</p>
- *         <p>When the reboot is complete, a cluster event is created.</p>
- *
- *         <p>Rebooting a cluster is currently supported on Memcached and Redis (cluster mode disabled) clusters.
- *             Rebooting is not supported on Redis (cluster mode enabled) clusters.</p>
- *
- *         <p>If you make changes to parameters that require a Redis (cluster mode enabled) cluster reboot for the changes to be applied,
- *             see <a href="http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Clusters.Rebooting.html">Rebooting a Cluster</a> for an alternate process.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, RebootCacheClusterCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, RebootCacheClusterCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new RebootCacheClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RebootCacheClusterCommandInput} for command's `input` shape.
- * @see {@link RebootCacheClusterCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RebootCacheClusterCommand extends $Command<RebootCacheClusterCommandInput, RebootCacheClusterCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: RebootCacheClusterCommandInput;
     constructor(input: RebootCacheClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RebootCacheClusterCommandInput, RebootCacheClusterCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/RemoveTagsFromResourceCommand.d.ts

@@ -6,32 +6,11 @@ export interface RemoveTagsFromResourceCommandInput extends RemoveTagsFromResour
 }
 export interface RemoveTagsFromResourceCommandOutput extends TagListMessage, __MetadataBearer {
 }
-/**
- * <p>Removes the tags identified by the <code>TagKeys</code>
- *             list from the named resource. A  tag is a key-value pair where the key and value are case-sensitive.
- *             You can use tags to categorize and track all your ElastiCache resources, with the exception of global replication group. When you add or remove tags on replication groups, those actions will be replicated to all nodes in the replication group.
- *         For more information, see <a href="http://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/IAM.ResourceLevelPermissions.html">Resource-level permissions</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, RemoveTagsFromResourceCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, RemoveTagsFromResourceCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new RemoveTagsFromResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RemoveTagsFromResourceCommandInput} for command's `input` shape.
- * @see {@link RemoveTagsFromResourceCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RemoveTagsFromResourceCommand extends $Command<RemoveTagsFromResourceCommandInput, RemoveTagsFromResourceCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: RemoveTagsFromResourceCommandInput;
     constructor(input: RemoveTagsFromResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveTagsFromResourceCommandInput, RemoveTagsFromResourceCommandOutput>;
     private serialize;
     private deserialize;