@aws-sdk/client-dax 3.35.0 → 3.38.0

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

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

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

@@ -6,33 +6,11 @@ export interface DescribeEventsCommandInput extends DescribeEventsRequest {
 }
 export interface DescribeEventsCommandOutput extends DescribeEventsResponse, __MetadataBearer {
 }
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { DAXClient, DescribeEventsCommand } from "@aws-sdk/client-dax"; // ES Modules import
- * // const { DAXClient, DescribeEventsCommand } = require("@aws-sdk/client-dax"); // CommonJS import
- * const client = new DAXClient(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 DAXClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEventsCommand extends $Command<DescribeEventsCommandInput, DescribeEventsCommandOutput, DAXClientResolvedConfig> {
     readonly input: DescribeEventsCommandInput;
     constructor(input: DescribeEventsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DAXClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEventsCommandInput, DescribeEventsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,21 @@
+export * from "./CreateClusterCommand";
+export * from "./CreateParameterGroupCommand";
+export * from "./CreateSubnetGroupCommand";
+export * from "./DecreaseReplicationFactorCommand";
+export * from "./DeleteClusterCommand";
+export * from "./DeleteParameterGroupCommand";
+export * from "./DeleteSubnetGroupCommand";
+export * from "./DescribeClustersCommand";
+export * from "./DescribeDefaultParametersCommand";
+export * from "./DescribeEventsCommand";
+export * from "./DescribeParameterGroupsCommand";
+export * from "./DescribeParametersCommand";
+export * from "./DescribeSubnetGroupsCommand";
+export * from "./IncreaseReplicationFactorCommand";
+export * from "./ListTagsCommand";
+export * from "./RebootNodeCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateClusterCommand";
+export * from "./UpdateParameterGroupCommand";
+export * from "./UpdateSubnetGroupCommand";

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

@@ -1,24 +1,4 @@
-export * from "./DAXClient";
 export * from "./DAX";
-export * from "./commands/CreateClusterCommand";
-export * from "./commands/CreateParameterGroupCommand";
-export * from "./commands/CreateSubnetGroupCommand";
-export * from "./commands/DecreaseReplicationFactorCommand";
-export * from "./commands/DeleteClusterCommand";
-export * from "./commands/DeleteParameterGroupCommand";
-export * from "./commands/DeleteSubnetGroupCommand";
-export * from "./commands/DescribeClustersCommand";
-export * from "./commands/DescribeDefaultParametersCommand";
-export * from "./commands/DescribeEventsCommand";
-export * from "./commands/DescribeParameterGroupsCommand";
-export * from "./commands/DescribeParametersCommand";
-export * from "./commands/DescribeSubnetGroupsCommand";
-export * from "./commands/IncreaseReplicationFactorCommand";
-export * from "./commands/ListTagsCommand";
-export * from "./commands/RebootNodeCommand";
-export * from "./commands/TagResourceCommand";
-export * from "./commands/UntagResourceCommand";
-export * from "./commands/UpdateClusterCommand";
-export * from "./commands/UpdateParameterGroupCommand";
-export * from "./commands/UpdateSubnetGroupCommand";
-export * from "./models/index";
+export * from "./DAXClient";
+export * from "./commands";
+export * from "./models";