@aws-sdk/client-elasticache 3.35.0 → 3.38.0

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

@@ -6,44 +6,11 @@ export interface DescribeCacheClustersCommandInput extends DescribeCacheClusters
 }
 export interface DescribeCacheClustersCommandOutput extends CacheClusterMessage, __MetadataBearer {
 }
-/**
- * <p>Returns information about all provisioned
- *             clusters if no cluster identifier is specified, or about a specific cache
- *             cluster if a cluster identifier is supplied.</p>
- *         <p>By default, abbreviated information about the clusters is returned. You can
- *             use the optional <i>ShowCacheNodeInfo</i> flag to retrieve detailed information about the
- *             cache nodes associated with the clusters. These details include the DNS address
- *             and port for the cache node endpoint.</p>
- *         <p>If the cluster is in the <i>creating</i> state, only cluster-level information is displayed
- *             until all of the nodes are successfully provisioned.</p>
- *         <p>If the cluster is in the <i>deleting</i> state, only cluster-level information is displayed.</p>
- *         <p>If cache nodes are currently being added to the cluster, node endpoint information
- *             and creation time for the additional nodes are not displayed until they are
- *             completely provisioned. When the cluster state is <i>available</i>, the cluster is
- *             ready for use.</p>
- *         <p>If cache nodes are currently being removed from the cluster, no endpoint information
- *             for the removed nodes is displayed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, DescribeCacheClustersCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, DescribeCacheClustersCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new DescribeCacheClustersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeCacheClustersCommandInput} for command's `input` shape.
- * @see {@link DescribeCacheClustersCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeCacheClustersCommand extends $Command<DescribeCacheClustersCommandInput, DescribeCacheClustersCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: DescribeCacheClustersCommandInput;
     constructor(input: DescribeCacheClustersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCacheClustersCommandInput, DescribeCacheClustersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeCacheEngineVersionsCommandInput extends DescribeCacheEn
 }
 export interface DescribeCacheEngineVersionsCommandOutput extends CacheEngineVersionMessage, __MetadataBearer {
 }
-/**
- * <p>Returns a list of the available cache
- *             engines and their versions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, DescribeCacheEngineVersionsCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, DescribeCacheEngineVersionsCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new DescribeCacheEngineVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeCacheEngineVersionsCommandInput} for command's `input` shape.
- * @see {@link DescribeCacheEngineVersionsCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeCacheEngineVersionsCommand extends $Command<DescribeCacheEngineVersionsCommandInput, DescribeCacheEngineVersionsCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: DescribeCacheEngineVersionsCommandInput;
     constructor(input: DescribeCacheEngineVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCacheEngineVersionsCommandInput, DescribeCacheEngineVersionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeCacheParameterGroupsCommandInput extends DescribeCacheP
 }
 export interface DescribeCacheParameterGroupsCommandOutput extends CacheParameterGroupsMessage, __MetadataBearer {
 }
-/**
- * <p>Returns a list of cache parameter group
- *             descriptions. If a cache parameter group name is specified, the list contains only
- *             the descriptions for that group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, DescribeCacheParameterGroupsCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, DescribeCacheParameterGroupsCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new DescribeCacheParameterGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeCacheParameterGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeCacheParameterGroupsCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeCacheParameterGroupsCommand extends $Command<DescribeCacheParameterGroupsCommandInput, DescribeCacheParameterGroupsCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: DescribeCacheParameterGroupsCommandInput;
     constructor(input: DescribeCacheParameterGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCacheParameterGroupsCommandInput, DescribeCacheParameterGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,32 +6,11 @@ export interface DescribeCacheSecurityGroupsCommandInput extends DescribeCacheSe
 }
 export interface DescribeCacheSecurityGroupsCommandOutput extends CacheSecurityGroupMessage, __MetadataBearer {
 }
-/**
- * <p>Returns a list of cache security group
- *             descriptions. If a cache security group name is specified, the list contains only
- *             the description of that group. This applicable only when you have ElastiCache in Classic setup
- *         </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, DescribeCacheSecurityGroupsCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, DescribeCacheSecurityGroupsCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new DescribeCacheSecurityGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeCacheSecurityGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeCacheSecurityGroupsCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeCacheSecurityGroupsCommand extends $Command<DescribeCacheSecurityGroupsCommandInput, DescribeCacheSecurityGroupsCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: DescribeCacheSecurityGroupsCommandInput;
     constructor(input: DescribeCacheSecurityGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCacheSecurityGroupsCommandInput, DescribeCacheSecurityGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribeCacheSubnetGroupsCommandInput extends DescribeCacheSubn
 }
 export interface DescribeCacheSubnetGroupsCommandOutput extends CacheSubnetGroupMessage, __MetadataBearer {
 }
-/**
- * <p>Returns a list of cache subnet group
- *             descriptions. If a subnet group name is specified, the list  contains only the
- *             description of that group. This is applicable only when you have ElastiCache in VPC setup. All ElastiCache clusters now launch in VPC by default.
- *         </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, DescribeCacheSubnetGroupsCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, DescribeCacheSubnetGroupsCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new DescribeCacheSubnetGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeCacheSubnetGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeCacheSubnetGroupsCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeCacheSubnetGroupsCommand extends $Command<DescribeCacheSubnetGroupsCommandInput, DescribeCacheSubnetGroupsCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: DescribeCacheSubnetGroupsCommandInput;
     constructor(input: DescribeCacheSubnetGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCacheSubnetGroupsCommandInput, DescribeCacheSubnetGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeEngineDefaultParametersCommandInput extends DescribeEng
 }
 export interface DescribeEngineDefaultParametersCommandOutput extends DescribeEngineDefaultParametersResult, __MetadataBearer {
 }
-/**
- * <p>Returns the default engine and
- *             system parameter information for the specified cache engine.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, DescribeEngineDefaultParametersCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, DescribeEngineDefaultParametersCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new DescribeEngineDefaultParametersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEngineDefaultParametersCommandInput} for command's `input` shape.
- * @see {@link DescribeEngineDefaultParametersCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEngineDefaultParametersCommand extends $Command<DescribeEngineDefaultParametersCommandInput, DescribeEngineDefaultParametersCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: DescribeEngineDefaultParametersCommandInput;
     constructor(input: DescribeEngineDefaultParametersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEngineDefaultParametersCommandInput, DescribeEngineDefaultParametersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DescribeEventsCommandInput extends DescribeEventsMessage {
 }
 export interface DescribeEventsCommandOutput extends EventsMessage, __MetadataBearer {
 }
-/**
- * <p>Returns events related to clusters, cache
- *             security groups, and cache parameter groups. You can obtain events specific to a
- *             particular cluster, cache security group, or cache parameter group by providing
- *             the name as a parameter.</p>
- *         <p>By default, only the events occurring within the last hour are returned;
- *             however, you can retrieve up to 14 days' worth of events if necessary.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, DescribeEventsCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, DescribeEventsCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new DescribeEventsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEventsCommandInput} for command's `input` shape.
- * @see {@link DescribeEventsCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEventsCommand extends $Command<DescribeEventsCommandInput, DescribeEventsCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: DescribeEventsCommandInput;
     constructor(input: DescribeEventsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEventsCommandInput, DescribeEventsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeGlobalReplicationGroupsCommandInput extends DescribeGlo
 }
 export interface DescribeGlobalReplicationGroupsCommandOutput extends DescribeGlobalReplicationGroupsResult, __MetadataBearer {
 }
-/**
- * <p>Returns information about a particular global replication group. If no identifier is specified, returns information about all Global datastores. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, DescribeGlobalReplicationGroupsCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, DescribeGlobalReplicationGroupsCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new DescribeGlobalReplicationGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeGlobalReplicationGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeGlobalReplicationGroupsCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeGlobalReplicationGroupsCommand extends $Command<DescribeGlobalReplicationGroupsCommandInput, DescribeGlobalReplicationGroupsCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: DescribeGlobalReplicationGroupsCommandInput;
     constructor(input: DescribeGlobalReplicationGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeGlobalReplicationGroupsCommandInput, DescribeGlobalReplicationGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DescribeReplicationGroupsCommandInput extends DescribeReplicati
 }
 export interface DescribeReplicationGroupsCommandOutput extends ReplicationGroupMessage, __MetadataBearer {
 }
-/**
- * <p>Returns information about a particular
- *             replication group. If no identifier is specified, <code>DescribeReplicationGroups</code>
- *             returns information about all replication groups.</p>
- *         <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, DescribeReplicationGroupsCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, DescribeReplicationGroupsCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new DescribeReplicationGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeReplicationGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeReplicationGroupsCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeReplicationGroupsCommand extends $Command<DescribeReplicationGroupsCommandInput, DescribeReplicationGroupsCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: DescribeReplicationGroupsCommandInput;
     constructor(input: DescribeReplicationGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeReplicationGroupsCommandInput, DescribeReplicationGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeReservedCacheNodesCommandInput extends DescribeReserved
 }
 export interface DescribeReservedCacheNodesCommandOutput extends ReservedCacheNodeMessage, __MetadataBearer {
 }
-/**
- * <p>Returns information about reserved cache
- *             nodes for this account, or about a specified reserved cache node.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, DescribeReservedCacheNodesCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, DescribeReservedCacheNodesCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new DescribeReservedCacheNodesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeReservedCacheNodesCommandInput} for command's `input` shape.
- * @see {@link DescribeReservedCacheNodesCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeReservedCacheNodesCommand extends $Command<DescribeReservedCacheNodesCommandInput, DescribeReservedCacheNodesCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: DescribeReservedCacheNodesCommandInput;
     constructor(input: DescribeReservedCacheNodesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeReservedCacheNodesCommandInput, DescribeReservedCacheNodesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,36 +6,11 @@ export interface DescribeSnapshotsCommandInput extends DescribeSnapshotsMessage
 }
 export interface DescribeSnapshotsCommandOutput extends DescribeSnapshotsListMessage, __MetadataBearer {
 }
-/**
- * <p>Returns information about cluster or replication group snapshots.
- *             By default, <code>DescribeSnapshots</code> lists all of your snapshots; it can optionally
- *             describe a single snapshot, or just the snapshots associated with a particular cache
- *             cluster.</p>
- *
- *         <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, DescribeSnapshotsCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, DescribeSnapshotsCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new DescribeSnapshotsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSnapshotsCommandInput} for command's `input` shape.
- * @see {@link DescribeSnapshotsCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSnapshotsCommand extends $Command<DescribeSnapshotsCommandInput, DescribeSnapshotsCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: DescribeSnapshotsCommandInput;
     constructor(input: DescribeSnapshotsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSnapshotsCommandInput, DescribeSnapshotsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface DisassociateGlobalReplicationGroupCommandInput extends Disassoc
 }
 export interface DisassociateGlobalReplicationGroupCommandOutput extends DisassociateGlobalReplicationGroupResult, __MetadataBearer {
 }
-/**
- * <p>Remove a secondary cluster from the Global datastore using the Global datastore name. The secondary cluster will no longer receive updates from the primary cluster, but will remain as a standalone cluster in that Amazon region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElastiCacheClient, DisassociateGlobalReplicationGroupCommand } from "@aws-sdk/client-elasticache"; // ES Modules import
- * // const { ElastiCacheClient, DisassociateGlobalReplicationGroupCommand } = require("@aws-sdk/client-elasticache"); // CommonJS import
- * const client = new ElastiCacheClient(config);
- * const command = new DisassociateGlobalReplicationGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateGlobalReplicationGroupCommandInput} for command's `input` shape.
- * @see {@link DisassociateGlobalReplicationGroupCommandOutput} for command's `response` shape.
- * @see {@link ElastiCacheClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateGlobalReplicationGroupCommand extends $Command<DisassociateGlobalReplicationGroupCommandInput, DisassociateGlobalReplicationGroupCommandOutput, ElastiCacheClientResolvedConfig> {
     readonly input: DisassociateGlobalReplicationGroupCommandInput;
     constructor(input: DisassociateGlobalReplicationGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElastiCacheClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateGlobalReplicationGroupCommandInput, DisassociateGlobalReplicationGroupCommandOutput>;
     private serialize;
     private deserialize;