@aws-sdk/client-dax 3.35.0 → 3.38.0

package/dist-types/ts3.4/DAX.d.ts

@@ -21,183 +21,89 @@ import { UpdateClusterCommandInput, UpdateClusterCommandOutput } from "./command
 import { UpdateParameterGroupCommandInput, UpdateParameterGroupCommandOutput } from "./commands/UpdateParameterGroupCommand";
 import { UpdateSubnetGroupCommandInput, UpdateSubnetGroupCommandOutput } from "./commands/UpdateSubnetGroupCommand";
 import { DAXClient } from "./DAXClient";
-/**
- * <p>DAX is a managed caching service engineered for Amazon DynamoDB. DAX
- *             dramatically speeds up database reads by caching frequently-accessed data from DynamoDB, so
- *             applications can access that data with sub-millisecond latency. You can create a DAX
- *             cluster easily, using the AWS Management Console. With a few simple modifications to
- *             your code, your application can begin taking advantage of the DAX cluster and realize
- *             significant improvements in read performance.</p>
- */
+
 export declare class DAX extends DAXClient {
-    /**
-     * <p>Creates a DAX cluster. All nodes in the cluster run the same DAX caching software.</p>
-     */
+    
     createCluster(args: CreateClusterCommandInput, options?: __HttpHandlerOptions): Promise<CreateClusterCommandOutput>;
     createCluster(args: CreateClusterCommandInput, cb: (err: any, data?: CreateClusterCommandOutput) => void): void;
     createCluster(args: CreateClusterCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateClusterCommandOutput) => void): void;
-    /**
-     * <p>Creates a new parameter group. A parameter group is a collection of parameters that
-     *             you apply to all of the nodes in a DAX cluster.</p>
-     */
+    
     createParameterGroup(args: CreateParameterGroupCommandInput, options?: __HttpHandlerOptions): Promise<CreateParameterGroupCommandOutput>;
     createParameterGroup(args: CreateParameterGroupCommandInput, cb: (err: any, data?: CreateParameterGroupCommandOutput) => void): void;
     createParameterGroup(args: CreateParameterGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateParameterGroupCommandOutput) => void): void;
-    /**
-     * <p>Creates a new subnet group.</p>
-     */
+    
     createSubnetGroup(args: CreateSubnetGroupCommandInput, options?: __HttpHandlerOptions): Promise<CreateSubnetGroupCommandOutput>;
     createSubnetGroup(args: CreateSubnetGroupCommandInput, cb: (err: any, data?: CreateSubnetGroupCommandOutput) => void): void;
     createSubnetGroup(args: CreateSubnetGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateSubnetGroupCommandOutput) => void): void;
-    /**
-     * <p>Removes one or more nodes from a DAX cluster.</p>
-     *         <note>
-     *             <p>You cannot use <code>DecreaseReplicationFactor</code> to remove the last node in a DAX cluster. If you need to do this, use <code>DeleteCluster</code> instead.</p>
-     *          </note>
-     */
+    
     decreaseReplicationFactor(args: DecreaseReplicationFactorCommandInput, options?: __HttpHandlerOptions): Promise<DecreaseReplicationFactorCommandOutput>;
     decreaseReplicationFactor(args: DecreaseReplicationFactorCommandInput, cb: (err: any, data?: DecreaseReplicationFactorCommandOutput) => void): void;
     decreaseReplicationFactor(args: DecreaseReplicationFactorCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DecreaseReplicationFactorCommandOutput) => void): void;
-    /**
-     * <p>Deletes a previously provisioned DAX cluster.
-     *                 <i>DeleteCluster</i> deletes all associated nodes, node endpoints
-     *             and the DAX cluster itself. When you receive a successful response from this action,
-     *             DAX immediately begins deleting the cluster; you cannot cancel or revert this
-     *             action.</p>
-     */
+    
     deleteCluster(args: DeleteClusterCommandInput, options?: __HttpHandlerOptions): Promise<DeleteClusterCommandOutput>;
     deleteCluster(args: DeleteClusterCommandInput, cb: (err: any, data?: DeleteClusterCommandOutput) => void): void;
     deleteCluster(args: DeleteClusterCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteClusterCommandOutput) => void): void;
-    /**
-     * <p>Deletes the specified parameter group. You cannot delete a parameter group if it is
-     *             associated with any DAX clusters.</p>
-     */
+    
     deleteParameterGroup(args: DeleteParameterGroupCommandInput, options?: __HttpHandlerOptions): Promise<DeleteParameterGroupCommandOutput>;
     deleteParameterGroup(args: DeleteParameterGroupCommandInput, cb: (err: any, data?: DeleteParameterGroupCommandOutput) => void): void;
     deleteParameterGroup(args: DeleteParameterGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteParameterGroupCommandOutput) => void): void;
-    /**
-     * <p>Deletes a subnet group.</p>
-     *         <note>
-     *             <p>You cannot delete a subnet group if it is associated with any DAX
-     *                 clusters.</p>
-     *         </note>
-     */
+    
     deleteSubnetGroup(args: DeleteSubnetGroupCommandInput, options?: __HttpHandlerOptions): Promise<DeleteSubnetGroupCommandOutput>;
     deleteSubnetGroup(args: DeleteSubnetGroupCommandInput, cb: (err: any, data?: DeleteSubnetGroupCommandOutput) => void): void;
     deleteSubnetGroup(args: DeleteSubnetGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteSubnetGroupCommandOutput) => void): void;
-    /**
-     * <p>Returns information about all provisioned DAX clusters if no cluster identifier
-     *             is specified, or about a specific DAX cluster if a cluster identifier is
-     *             supplied.</p>
-     *         <p>If the cluster is in the CREATING state, only cluster level information will be
-     *             displayed until all of the nodes are successfully provisioned.</p>
-     *         <p>If the cluster is in the DELETING state, only cluster level information will be
-     *             displayed.</p>
-     *         <p>If nodes are currently being added to the DAX cluster, node endpoint information
-     *             and creation time for the additional nodes will not be displayed until they are
-     *             completely provisioned. When the DAX cluster state is <i>available</i>,
-     *             the cluster is ready for use.</p>
-     *         <p>If nodes are currently being removed from the DAX cluster, no endpoint
-     *             information for the removed nodes is displayed.</p>
-     */
+    
     describeClusters(args: DescribeClustersCommandInput, options?: __HttpHandlerOptions): Promise<DescribeClustersCommandOutput>;
     describeClusters(args: DescribeClustersCommandInput, cb: (err: any, data?: DescribeClustersCommandOutput) => void): void;
     describeClusters(args: DescribeClustersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeClustersCommandOutput) => void): void;
-    /**
-     * <p>Returns the default system parameter information for the DAX caching
-     *             software.</p>
-     */
+    
     describeDefaultParameters(args: DescribeDefaultParametersCommandInput, options?: __HttpHandlerOptions): Promise<DescribeDefaultParametersCommandOutput>;
     describeDefaultParameters(args: DescribeDefaultParametersCommandInput, cb: (err: any, data?: DescribeDefaultParametersCommandOutput) => void): void;
     describeDefaultParameters(args: DescribeDefaultParametersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeDefaultParametersCommandOutput) => void): void;
-    /**
-     * <p>Returns events related to DAX clusters and parameter groups. You can obtain
-     *             events specific to a particular DAX cluster or parameter group by providing the name
-     *             as a parameter.</p>
-     *         <p>By default, only the events occurring within the last 24 hours are returned; however,
-     *             you can retrieve up to 14 days' worth of events if necessary.</p>
-     */
+    
     describeEvents(args: DescribeEventsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeEventsCommandOutput>;
     describeEvents(args: DescribeEventsCommandInput, cb: (err: any, data?: DescribeEventsCommandOutput) => void): void;
     describeEvents(args: DescribeEventsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeEventsCommandOutput) => void): void;
-    /**
-     * <p>Returns a list of parameter group descriptions. If a parameter group name is
-     *             specified, the list will contain only the descriptions for that group.</p>
-     */
+    
     describeParameterGroups(args: DescribeParameterGroupsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeParameterGroupsCommandOutput>;
     describeParameterGroups(args: DescribeParameterGroupsCommandInput, cb: (err: any, data?: DescribeParameterGroupsCommandOutput) => void): void;
     describeParameterGroups(args: DescribeParameterGroupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeParameterGroupsCommandOutput) => void): void;
-    /**
-     * <p>Returns the detailed parameter list for a particular parameter group.</p>
-     */
+    
     describeParameters(args: DescribeParametersCommandInput, options?: __HttpHandlerOptions): Promise<DescribeParametersCommandOutput>;
     describeParameters(args: DescribeParametersCommandInput, cb: (err: any, data?: DescribeParametersCommandOutput) => void): void;
     describeParameters(args: DescribeParametersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeParametersCommandOutput) => void): void;
-    /**
-     * <p>Returns a list of subnet group descriptions. If a subnet group name is specified,
-     *             the list will contain only the description of that group.</p>
-     */
+    
     describeSubnetGroups(args: DescribeSubnetGroupsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeSubnetGroupsCommandOutput>;
     describeSubnetGroups(args: DescribeSubnetGroupsCommandInput, cb: (err: any, data?: DescribeSubnetGroupsCommandOutput) => void): void;
     describeSubnetGroups(args: DescribeSubnetGroupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeSubnetGroupsCommandOutput) => void): void;
-    /**
-     * <p>Adds one or more nodes to a DAX cluster.</p>
-     */
+    
     increaseReplicationFactor(args: IncreaseReplicationFactorCommandInput, options?: __HttpHandlerOptions): Promise<IncreaseReplicationFactorCommandOutput>;
     increaseReplicationFactor(args: IncreaseReplicationFactorCommandInput, cb: (err: any, data?: IncreaseReplicationFactorCommandOutput) => void): void;
     increaseReplicationFactor(args: IncreaseReplicationFactorCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: IncreaseReplicationFactorCommandOutput) => void): void;
-    /**
-     * <p>List all of the tags for a DAX cluster. You can call <code>ListTags</code> up to
-     *             10 times per second, per account.</p>
-     */
+    
     listTags(args: ListTagsCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsCommandOutput>;
     listTags(args: ListTagsCommandInput, cb: (err: any, data?: ListTagsCommandOutput) => void): void;
     listTags(args: ListTagsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsCommandOutput) => void): void;
-    /**
-     * <p>Reboots a single node of a DAX cluster. The reboot action takes place
-     *             as soon as possible. During the
-     *             reboot, the node status is set to REBOOTING.</p>
-     *         <note>
-     *             <p>
-     *                <code>RebootNode</code> restarts the DAX engine process and does not remove the contents of the cache.  </p>
-     *         </note>
-     */
+    
     rebootNode(args: RebootNodeCommandInput, options?: __HttpHandlerOptions): Promise<RebootNodeCommandOutput>;
     rebootNode(args: RebootNodeCommandInput, cb: (err: any, data?: RebootNodeCommandOutput) => void): void;
     rebootNode(args: RebootNodeCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: RebootNodeCommandOutput) => void): void;
-    /**
-     * <p>Associates a set of tags with a DAX resource.  You can call <code>TagResource</code> up to 5 times per second, per
-     *             account. </p>
-     */
+    
     tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
     tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
     tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
-    /**
-     * <p>Removes the association of tags from a DAX resource. You can call
-     *             <code>UntagResource</code> up to 5 times per second, per account. </p>
-     */
+    
     untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Promise<UntagResourceCommandOutput>;
     untagResource(args: UntagResourceCommandInput, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
     untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
-    /**
-     * <p>Modifies the settings for a DAX cluster. You can use this action to change one or
-     *             more cluster configuration parameters by specifying the parameters and the new
-     *             values.</p>
-     */
+    
     updateCluster(args: UpdateClusterCommandInput, options?: __HttpHandlerOptions): Promise<UpdateClusterCommandOutput>;
     updateCluster(args: UpdateClusterCommandInput, cb: (err: any, data?: UpdateClusterCommandOutput) => void): void;
     updateCluster(args: UpdateClusterCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateClusterCommandOutput) => void): void;
-    /**
-     * <p>Modifies the parameters of a parameter group. You can modify up to 20
-     *             parameters in a single request by submitting a list parameter name and value
-     *             pairs.</p>
-     */
+    
     updateParameterGroup(args: UpdateParameterGroupCommandInput, options?: __HttpHandlerOptions): Promise<UpdateParameterGroupCommandOutput>;
     updateParameterGroup(args: UpdateParameterGroupCommandInput, cb: (err: any, data?: UpdateParameterGroupCommandOutput) => void): void;
     updateParameterGroup(args: UpdateParameterGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateParameterGroupCommandOutput) => void): void;
-    /**
-     * <p>Modifies an existing subnet group.</p>
-     */
+    
     updateSubnetGroup(args: UpdateSubnetGroupCommandInput, options?: __HttpHandlerOptions): Promise<UpdateSubnetGroupCommandOutput>;
     updateSubnetGroup(args: UpdateSubnetGroupCommandInput, cb: (err: any, data?: UpdateSubnetGroupCommandOutput) => void): void;
     updateSubnetGroup(args: UpdateSubnetGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateSubnetGroupCommandOutput) => void): void;

package/dist-types/ts3.4/DAXClient.d.ts

@@ -30,129 +30,59 @@ import { UpdateSubnetGroupCommandInput, UpdateSubnetGroupCommandOutput } from ".
 export declare type ServiceInputTypes = CreateClusterCommandInput | CreateParameterGroupCommandInput | CreateSubnetGroupCommandInput | DecreaseReplicationFactorCommandInput | DeleteClusterCommandInput | DeleteParameterGroupCommandInput | DeleteSubnetGroupCommandInput | DescribeClustersCommandInput | DescribeDefaultParametersCommandInput | DescribeEventsCommandInput | DescribeParameterGroupsCommandInput | DescribeParametersCommandInput | DescribeSubnetGroupsCommandInput | IncreaseReplicationFactorCommandInput | ListTagsCommandInput | RebootNodeCommandInput | TagResourceCommandInput | UntagResourceCommandInput | UpdateClusterCommandInput | UpdateParameterGroupCommandInput | UpdateSubnetGroupCommandInput;
 export declare type ServiceOutputTypes = CreateClusterCommandOutput | CreateParameterGroupCommandOutput | CreateSubnetGroupCommandOutput | DecreaseReplicationFactorCommandOutput | DeleteClusterCommandOutput | DeleteParameterGroupCommandOutput | DeleteSubnetGroupCommandOutput | DescribeClustersCommandOutput | DescribeDefaultParametersCommandOutput | DescribeEventsCommandOutput | DescribeParameterGroupsCommandOutput | DescribeParametersCommandOutput | DescribeSubnetGroupsCommandOutput | IncreaseReplicationFactorCommandOutput | ListTagsCommandOutput | RebootNodeCommandOutput | TagResourceCommandOutput | UntagResourceCommandOutput | UpdateClusterCommandOutput | UpdateParameterGroupCommandOutput | UpdateSubnetGroupCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type DAXClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of DAXClient class constructor that set the region, credentials and other options.
- */
+
 export interface DAXClientConfig extends DAXClientConfigType {
 }
 declare type DAXClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of DAXClient class. This is resolved and normalized from the {@link DAXClientConfig | constructor configuration interface}.
- */
+
 export interface DAXClientResolvedConfig extends DAXClientResolvedConfigType {
 }
-/**
- * <p>DAX is a managed caching service engineered for Amazon DynamoDB. DAX
- *             dramatically speeds up database reads by caching frequently-accessed data from DynamoDB, so
- *             applications can access that data with sub-millisecond latency. You can create a DAX
- *             cluster easily, using the AWS Management Console. With a few simple modifications to
- *             your code, your application can begin taking advantage of the DAX cluster and realize
- *             significant improvements in read performance.</p>
- */
+
 export declare class DAXClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, DAXClientResolvedConfig> {
-    /**
-     * The resolved configuration of DAXClient class. This is resolved and normalized from the {@link DAXClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: DAXClientResolvedConfig;
     constructor(configuration: DAXClientConfig);
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
+    
     destroy(): void;
 }
 export {};

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

@@ -6,29 +6,11 @@ export interface CreateClusterCommandInput extends CreateClusterRequest {
 }
 export interface CreateClusterCommandOutput extends CreateClusterResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a DAX cluster. All nodes in the cluster run the same DAX caching software.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DAXClient, CreateClusterCommand } from "@aws-sdk/client-dax"; // ES Modules import
- * // const { DAXClient, CreateClusterCommand } = require("@aws-sdk/client-dax"); // CommonJS import
- * const client = new DAXClient(config);
- * const command = new CreateClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateClusterCommandInput} for command's `input` shape.
- * @see {@link CreateClusterCommandOutput} for command's `response` shape.
- * @see {@link DAXClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateClusterCommand extends $Command<CreateClusterCommandInput, CreateClusterCommandOutput, DAXClientResolvedConfig> {
     readonly input: CreateClusterCommandInput;
     constructor(input: CreateClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DAXClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClusterCommandInput, CreateClusterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreateParameterGroupCommandInput extends CreateParameterGroupRe
 }
 export interface CreateParameterGroupCommandOutput extends CreateParameterGroupResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new parameter group. A parameter group is a collection of parameters that
- *             you apply to all of the nodes in a DAX cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DAXClient, CreateParameterGroupCommand } from "@aws-sdk/client-dax"; // ES Modules import
- * // const { DAXClient, CreateParameterGroupCommand } = require("@aws-sdk/client-dax"); // CommonJS import
- * const client = new DAXClient(config);
- * const command = new CreateParameterGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateParameterGroupCommandInput} for command's `input` shape.
- * @see {@link CreateParameterGroupCommandOutput} for command's `response` shape.
- * @see {@link DAXClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateParameterGroupCommand extends $Command<CreateParameterGroupCommandInput, CreateParameterGroupCommandOutput, DAXClientResolvedConfig> {
     readonly input: CreateParameterGroupCommandInput;
     constructor(input: CreateParameterGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DAXClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateParameterGroupCommandInput, CreateParameterGroupCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,32 +6,11 @@ export interface DecreaseReplicationFactorCommandInput extends DecreaseReplicati
 }
 export interface DecreaseReplicationFactorCommandOutput extends DecreaseReplicationFactorResponse, __MetadataBearer {
 }
-/**
- * <p>Removes one or more nodes from a DAX cluster.</p>
- *         <note>
- *             <p>You cannot use <code>DecreaseReplicationFactor</code> to remove the last node in a DAX cluster. If you need to do this, use <code>DeleteCluster</code> instead.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DAXClient, DecreaseReplicationFactorCommand } from "@aws-sdk/client-dax"; // ES Modules import
- * // const { DAXClient, DecreaseReplicationFactorCommand } = require("@aws-sdk/client-dax"); // CommonJS import
- * const client = new DAXClient(config);
- * const command = new DecreaseReplicationFactorCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DecreaseReplicationFactorCommandInput} for command's `input` shape.
- * @see {@link DecreaseReplicationFactorCommandOutput} for command's `response` shape.
- * @see {@link DAXClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DecreaseReplicationFactorCommand extends $Command<DecreaseReplicationFactorCommandInput, DecreaseReplicationFactorCommandOutput, DAXClientResolvedConfig> {
     readonly input: DecreaseReplicationFactorCommandInput;
     constructor(input: DecreaseReplicationFactorCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DAXClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DecreaseReplicationFactorCommandInput, DecreaseReplicationFactorCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DeleteClusterCommandInput extends DeleteClusterRequest {
 }
 export interface DeleteClusterCommandOutput extends DeleteClusterResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a previously provisioned DAX cluster.
- *                 <i>DeleteCluster</i> deletes all associated nodes, node endpoints
- *             and the DAX cluster itself. When you receive a successful response from this action,
- *             DAX immediately begins deleting the cluster; you cannot cancel or revert this
- *             action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DAXClient, DeleteClusterCommand } from "@aws-sdk/client-dax"; // ES Modules import
- * // const { DAXClient, DeleteClusterCommand } = require("@aws-sdk/client-dax"); // CommonJS import
- * const client = new DAXClient(config);
- * const command = new DeleteClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteClusterCommandInput} for command's `input` shape.
- * @see {@link DeleteClusterCommandOutput} for command's `response` shape.
- * @see {@link DAXClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteClusterCommand extends $Command<DeleteClusterCommandInput, DeleteClusterCommandOutput, DAXClientResolvedConfig> {
     readonly input: DeleteClusterCommandInput;
     constructor(input: DeleteClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DAXClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteClusterCommandInput, DeleteClusterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteParameterGroupCommandInput extends DeleteParameterGroupRe
 }
 export interface DeleteParameterGroupCommandOutput extends DeleteParameterGroupResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified parameter group. You cannot delete a parameter group if it is
- *             associated with any DAX clusters.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DAXClient, DeleteParameterGroupCommand } from "@aws-sdk/client-dax"; // ES Modules import
- * // const { DAXClient, DeleteParameterGroupCommand } = require("@aws-sdk/client-dax"); // CommonJS import
- * const client = new DAXClient(config);
- * const command = new DeleteParameterGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteParameterGroupCommandInput} for command's `input` shape.
- * @see {@link DeleteParameterGroupCommandOutput} for command's `response` shape.
- * @see {@link DAXClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteParameterGroupCommand extends $Command<DeleteParameterGroupCommandInput, DeleteParameterGroupCommandOutput, DAXClientResolvedConfig> {
     readonly input: DeleteParameterGroupCommandInput;
     constructor(input: DeleteParameterGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DAXClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteParameterGroupCommandInput, DeleteParameterGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DeleteSubnetGroupCommandInput extends DeleteSubnetGroupRequest
 }
 export interface DeleteSubnetGroupCommandOutput extends DeleteSubnetGroupResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a subnet group.</p>
- *         <note>
- *             <p>You cannot delete a subnet group if it is associated with any DAX
- *                 clusters.</p>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DAXClient, DeleteSubnetGroupCommand } from "@aws-sdk/client-dax"; // ES Modules import
- * // const { DAXClient, DeleteSubnetGroupCommand } = require("@aws-sdk/client-dax"); // CommonJS import
- * const client = new DAXClient(config);
- * const command = new DeleteSubnetGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteSubnetGroupCommandInput} for command's `input` shape.
- * @see {@link DeleteSubnetGroupCommandOutput} for command's `response` shape.
- * @see {@link DAXClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteSubnetGroupCommand extends $Command<DeleteSubnetGroupCommandInput, DeleteSubnetGroupCommandOutput, DAXClientResolvedConfig> {
     readonly input: DeleteSubnetGroupCommandInput;
     constructor(input: DeleteSubnetGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DAXClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSubnetGroupCommandInput, DeleteSubnetGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,41 +6,11 @@ export interface DescribeClustersCommandInput extends DescribeClustersRequest {
 }
 export interface DescribeClustersCommandOutput extends DescribeClustersResponse, __MetadataBearer {
 }
-/**
- * <p>Returns information about all provisioned DAX clusters if no cluster identifier
- *             is specified, or about a specific DAX cluster if a cluster identifier is
- *             supplied.</p>
- *         <p>If the cluster is in the CREATING state, only cluster level information will be
- *             displayed until all of the nodes are successfully provisioned.</p>
- *         <p>If the cluster is in the DELETING state, only cluster level information will be
- *             displayed.</p>
- *         <p>If nodes are currently being added to the DAX cluster, node endpoint information
- *             and creation time for the additional nodes will not be displayed until they are
- *             completely provisioned. When the DAX cluster state is <i>available</i>,
- *             the cluster is ready for use.</p>
- *         <p>If nodes are currently being removed from the DAX 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 { DAXClient, DescribeClustersCommand } from "@aws-sdk/client-dax"; // ES Modules import
- * // const { DAXClient, DescribeClustersCommand } = require("@aws-sdk/client-dax"); // CommonJS import
- * const client = new DAXClient(config);
- * const command = new DescribeClustersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeClustersCommandInput} for command's `input` shape.
- * @see {@link DescribeClustersCommandOutput} for command's `response` shape.
- * @see {@link DAXClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeClustersCommand extends $Command<DescribeClustersCommandInput, DescribeClustersCommandOutput, DAXClientResolvedConfig> {
     readonly input: DescribeClustersCommandInput;
     constructor(input: DescribeClustersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DAXClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeClustersCommandInput, DescribeClustersCommandOutput>;
     private serialize;
     private deserialize;