@aws-sdk/client-efs 3.35.0 → 3.38.0

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

@@ -6,62 +6,11 @@ export interface DeleteMountTargetCommandInput extends DeleteMountTargetRequest
 }
 export interface DeleteMountTargetCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified mount target.</p>
- *
- *          <p>This operation forcibly breaks any mounts of the file system by using the mount target
- *       that is being deleted, which might disrupt instances or applications using those mounts. To
- *       avoid applications getting cut off abruptly, you might consider unmounting any mounts of the
- *       mount target, if feasible. The operation also deletes the associated network interface.
- *       Uncommitted writes might be lost, but breaking a mount target using this operation does not
- *       corrupt the file system itself. The file system you created remains. You can mount an EC2
- *       instance in your VPC by using another mount target.</p>
- *          <p>This operation requires permissions for the following action on the file
- *       system:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <code>elasticfilesystem:DeleteMountTarget</code>
- *                </p>
- *             </li>
- *          </ul>
- *
- *          <note>
- *             <p>The <code>DeleteMountTarget</code> call returns while the mount target state is still
- *           <code>deleting</code>. You can check the mount target deletion by calling the <a>DescribeMountTargets</a> operation, which returns a list of mount target
- *         descriptions for the given file system. </p>
- *          </note>
- *
- *          <p>The operation also requires permissions for the following Amazon EC2 action on the
- *       mount target's network interface:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <code>ec2:DeleteNetworkInterface</code>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, DeleteMountTargetCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, DeleteMountTargetCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new DeleteMountTargetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteMountTargetCommandInput} for command's `input` shape.
- * @see {@link DeleteMountTargetCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteMountTargetCommand extends $Command<DeleteMountTargetCommandInput, DeleteMountTargetCommandOutput, EFSClientResolvedConfig> {
     readonly input: DeleteMountTargetCommandInput;
     constructor(input: DeleteMountTargetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteMountTargetCommandInput, DeleteMountTargetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,41 +6,11 @@ export interface DeleteTagsCommandInput extends DeleteTagsRequest {
 }
 export interface DeleteTagsCommandOutput extends __MetadataBearer {
 }
-/**
- * @deprecated
- *
- * <note>
- *             <p>DEPRECATED - DeleteTags is deprecated and not maintained. Please use the
- *        API action to remove tags from EFS resources.</p>
- *          </note>
- *          <p>Deletes the specified tags from a file system. If the <code>DeleteTags</code> request
- *       includes a tag key that doesn't exist, Amazon EFS ignores it and doesn't cause an
- *       error. For more information about tags and related restrictions, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html">Tag restrictions</a> in the
- *         <i>Billing and Cost Management User Guide</i>.</p>
- *
- *          <p>This operation requires permissions for the <code>elasticfilesystem:DeleteTags</code>
- *       action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, DeleteTagsCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, DeleteTagsCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new DeleteTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTagsCommandInput} for command's `input` shape.
- * @see {@link DeleteTagsCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteTagsCommand extends $Command<DeleteTagsCommandInput, DeleteTagsCommandOutput, EFSClientResolvedConfig> {
     readonly input: DeleteTagsCommandInput;
     constructor(input: DeleteTagsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTagsCommandInput, DeleteTagsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribeAccessPointsCommandInput extends DescribeAccessPointsRe
 }
 export interface DescribeAccessPointsCommandOutput extends DescribeAccessPointsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the description of a specific Amazon EFS access point if the <code>AccessPointId</code> is provided.
- *       If you provide an EFS <code>FileSystemId</code>, it returns descriptions of all access points for that file system.
- *       You can provide either an <code>AccessPointId</code> or a <code>FileSystemId</code> in the request, but not both. </p>
- *          <p>This operation requires permissions for the <code>elasticfilesystem:DescribeAccessPoints</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, DescribeAccessPointsCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, DescribeAccessPointsCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new DescribeAccessPointsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAccessPointsCommandInput} for command's `input` shape.
- * @see {@link DescribeAccessPointsCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAccessPointsCommand extends $Command<DescribeAccessPointsCommandInput, DescribeAccessPointsCommandOutput, EFSClientResolvedConfig> {
     readonly input: DescribeAccessPointsCommandInput;
     constructor(input: DescribeAccessPointsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAccessPointsCommandInput, DescribeAccessPointsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeAccountPreferencesCommandInput extends DescribeAccountP
 }
 export interface DescribeAccountPreferencesCommandOutput extends DescribeAccountPreferencesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the account preferences settings for the Amazon Web Services account associated with the user making the request, in the current Amazon Web Services Region.
- *       For more information, see <a href="efs/latest/ug/manage-efs-resource-ids.html">Managing Amazon EFS resource IDs</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, DescribeAccountPreferencesCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, DescribeAccountPreferencesCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new DescribeAccountPreferencesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAccountPreferencesCommandInput} for command's `input` shape.
- * @see {@link DescribeAccountPreferencesCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAccountPreferencesCommand extends $Command<DescribeAccountPreferencesCommandInput, DescribeAccountPreferencesCommandOutput, EFSClientResolvedConfig> {
     readonly input: DescribeAccountPreferencesCommandInput;
     constructor(input: DescribeAccountPreferencesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAccountPreferencesCommandInput, DescribeAccountPreferencesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeBackupPolicyCommandInput extends DescribeBackupPolicyRe
 }
 export interface DescribeBackupPolicyCommandOutput extends BackupPolicyDescription, __MetadataBearer {
 }
-/**
- * <p>Returns the backup policy for the specified EFS file system.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, DescribeBackupPolicyCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, DescribeBackupPolicyCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new DescribeBackupPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeBackupPolicyCommandInput} for command's `input` shape.
- * @see {@link DescribeBackupPolicyCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeBackupPolicyCommand extends $Command<DescribeBackupPolicyCommandInput, DescribeBackupPolicyCommandOutput, EFSClientResolvedConfig> {
     readonly input: DescribeBackupPolicyCommandInput;
     constructor(input: DescribeBackupPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeBackupPolicyCommandInput, DescribeBackupPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeFileSystemPolicyCommandInput extends DescribeFileSystem
 }
 export interface DescribeFileSystemPolicyCommandOutput extends FileSystemPolicyDescription, __MetadataBearer {
 }
-/**
- * <p>Returns the <code>FileSystemPolicy</code> for the specified EFS file system.</p>
- *          <p>This operation requires permissions for the <code>elasticfilesystem:DescribeFileSystemPolicy</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, DescribeFileSystemPolicyCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, DescribeFileSystemPolicyCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new DescribeFileSystemPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeFileSystemPolicyCommandInput} for command's `input` shape.
- * @see {@link DescribeFileSystemPolicyCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeFileSystemPolicyCommand extends $Command<DescribeFileSystemPolicyCommandInput, DescribeFileSystemPolicyCommandOutput, EFSClientResolvedConfig> {
     readonly input: DescribeFileSystemPolicyCommandInput;
     constructor(input: DescribeFileSystemPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFileSystemPolicyCommandInput, DescribeFileSystemPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,51 +6,11 @@ export interface DescribeFileSystemsCommandInput extends DescribeFileSystemsRequ
 }
 export interface DescribeFileSystemsCommandOutput extends DescribeFileSystemsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the description of a specific Amazon EFS file system if either the file system
- *         <code>CreationToken</code> or the <code>FileSystemId</code> is provided. Otherwise, it
- *       returns descriptions of all file systems owned by the caller's Amazon Web Services account in the
- *       Amazon Web Services Region of the endpoint that you're calling.</p>
- *
- *          <p>When retrieving all file system descriptions, you can optionally specify the
- *         <code>MaxItems</code> parameter to limit the number of descriptions in a response.
- *       Currently, this number is automatically set to 10. If more file system descriptions remain,
- *       Amazon EFS returns a <code>NextMarker</code>, an opaque token, in the response. In this case,
- *       you should send a subsequent request with the <code>Marker</code> request parameter set to the
- *       value of <code>NextMarker</code>. </p>
- *
- *          <p>To retrieve a list of your file system descriptions, this operation is used in an
- *       iterative process, where <code>DescribeFileSystems</code> is called first without the
- *         <code>Marker</code> and then the operation continues to call it with the <code>Marker</code>
- *       parameter set to the value of the <code>NextMarker</code> from the previous response until the
- *       response has no <code>NextMarker</code>. </p>
- *
- *          <p> The order of file systems returned in the response of one
- *         <code>DescribeFileSystems</code> call and the order of file systems returned across the
- *       responses of a multi-call iteration is unspecified. </p>
- *          <p> This operation requires permissions for the
- *         <code>elasticfilesystem:DescribeFileSystems</code> action. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, DescribeFileSystemsCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, DescribeFileSystemsCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new DescribeFileSystemsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeFileSystemsCommandInput} for command's `input` shape.
- * @see {@link DescribeFileSystemsCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeFileSystemsCommand extends $Command<DescribeFileSystemsCommandInput, DescribeFileSystemsCommandOutput, EFSClientResolvedConfig> {
     readonly input: DescribeFileSystemsCommandInput;
     constructor(input: DescribeFileSystemsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFileSystemsCommandInput, DescribeFileSystemsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface DescribeLifecycleConfigurationCommandInput extends DescribeLife
 }
 export interface DescribeLifecycleConfigurationCommandOutput extends LifecycleConfigurationDescription, __MetadataBearer {
 }
-/**
- * <p>Returns the current <code>LifecycleConfiguration</code> object for the specified Amazon
- *       EFS file system. EFS lifecycle management uses the <code>LifecycleConfiguration</code> object
- *       to identify which files to move to the EFS Infrequent Access (IA) storage class. For a file system
- *       without a <code>LifecycleConfiguration</code> object, the call returns an empty array in the
- *       response.</p>
- *          <p>When EFS Intelligent Tiering is enabled, <code>TransitionToPrimaryStorageClass</code> has a value of <code>AFTER_1_ACCESS</code>.</p>
- *          <p>This operation requires permissions for the
- *         <code>elasticfilesystem:DescribeLifecycleConfiguration</code> operation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, DescribeLifecycleConfigurationCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, DescribeLifecycleConfigurationCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new DescribeLifecycleConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLifecycleConfigurationCommandInput} for command's `input` shape.
- * @see {@link DescribeLifecycleConfigurationCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLifecycleConfigurationCommand extends $Command<DescribeLifecycleConfigurationCommandInput, DescribeLifecycleConfigurationCommandOutput, EFSClientResolvedConfig> {
     readonly input: DescribeLifecycleConfigurationCommandInput;
     constructor(input: DescribeLifecycleConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLifecycleConfigurationCommandInput, DescribeLifecycleConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,44 +6,11 @@ export interface DescribeMountTargetSecurityGroupsCommandInput extends DescribeM
 }
 export interface DescribeMountTargetSecurityGroupsCommandOutput extends DescribeMountTargetSecurityGroupsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the security groups currently in effect for a mount target. This operation
- *       requires that the network interface of the mount target has been created and the lifecycle
- *       state of the mount target is not <code>deleted</code>.</p>
- *          <p>This operation requires permissions for the following actions:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <code>elasticfilesystem:DescribeMountTargetSecurityGroups</code> action on the mount
- *           target's file system. </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>ec2:DescribeNetworkInterfaceAttribute</code> action on the mount target's
- *           network interface. </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, DescribeMountTargetSecurityGroupsCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, DescribeMountTargetSecurityGroupsCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new DescribeMountTargetSecurityGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeMountTargetSecurityGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeMountTargetSecurityGroupsCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeMountTargetSecurityGroupsCommand extends $Command<DescribeMountTargetSecurityGroupsCommandInput, DescribeMountTargetSecurityGroupsCommandOutput, EFSClientResolvedConfig> {
     readonly input: DescribeMountTargetSecurityGroupsCommandInput;
     constructor(input: DescribeMountTargetSecurityGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeMountTargetSecurityGroupsCommandInput, DescribeMountTargetSecurityGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface DescribeMountTargetsCommandInput extends DescribeMountTargetsRe
 }
 export interface DescribeMountTargetsCommandOutput extends DescribeMountTargetsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the descriptions of all the current mount targets, or a specific mount target,
- *       for a file system. When requesting all of the current mount targets, the order of mount
- *       targets returned in the response is unspecified.</p>
- *
- *          <p>This operation requires permissions for the
- *         <code>elasticfilesystem:DescribeMountTargets</code> action, on either the file system ID
- *       that you specify in <code>FileSystemId</code>, or on the file system of the mount target that
- *       you specify in <code>MountTargetId</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, DescribeMountTargetsCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, DescribeMountTargetsCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new DescribeMountTargetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeMountTargetsCommandInput} for command's `input` shape.
- * @see {@link DescribeMountTargetsCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeMountTargetsCommand extends $Command<DescribeMountTargetsCommandInput, DescribeMountTargetsCommandOutput, EFSClientResolvedConfig> {
     readonly input: DescribeMountTargetsCommandInput;
     constructor(input: DescribeMountTargetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeMountTargetsCommandInput, DescribeMountTargetsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface DescribeTagsCommandInput extends DescribeTagsRequest {
 }
 export interface DescribeTagsCommandOutput extends DescribeTagsResponse, __MetadataBearer {
 }
-/**
- * @deprecated
- *
- * <note>
- *             <p>DEPRECATED - The DeleteTags action is deprecated and not maintained. Please use the
- *          API action to remove tags from EFS resources.</p>
- *          </note>
- *          <p>Returns the tags associated with a file system. The order of tags returned in the
- *       response of one <code>DescribeTags</code> call and the order of tags returned across the
- *       responses of a multiple-call iteration (when using pagination) is unspecified. </p>
- *          <p> This operation requires permissions for the
- *         <code>elasticfilesystem:DescribeTags</code> action. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, DescribeTagsCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, DescribeTagsCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new DescribeTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTagsCommandInput} for command's `input` shape.
- * @see {@link DescribeTagsCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTagsCommand extends $Command<DescribeTagsCommandInput, DescribeTagsCommandOutput, EFSClientResolvedConfig> {
     readonly input: DescribeTagsCommandInput;
     constructor(input: DescribeTagsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTagsCommandInput, DescribeTagsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Lists all tags for a top-level EFS resource. You must provide the ID of the resource that you want to retrieve the tags for.</p>
- *          <p>This operation requires permissions for the <code>elasticfilesystem:DescribeAccessPoints</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, ListTagsForResourceCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, ListTagsForResourceCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, EFSClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,48 +6,11 @@ export interface ModifyMountTargetSecurityGroupsCommandInput extends ModifyMount
 }
 export interface ModifyMountTargetSecurityGroupsCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Modifies the set of security groups in effect for a mount target.</p>
- *          <p>When you create a mount target, Amazon EFS also creates a new network interface. For
- *       more information, see <a>CreateMountTarget</a>. This operation replaces the security groups in effect for the
- *       network interface associated with a mount target, with the <code>SecurityGroups</code>
- *       provided in the request. This operation requires that the network interface of the mount
- *       target has been created and the lifecycle state of the mount target is not
- *         <code>deleted</code>. </p>
- *          <p>The operation requires permissions for the following actions:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <code>elasticfilesystem:ModifyMountTargetSecurityGroups</code> action on the mount
- *           target's file system. </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>ec2:ModifyNetworkInterfaceAttribute</code> action on the mount target's network
- *           interface. </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, ModifyMountTargetSecurityGroupsCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, ModifyMountTargetSecurityGroupsCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new ModifyMountTargetSecurityGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyMountTargetSecurityGroupsCommandInput} for command's `input` shape.
- * @see {@link ModifyMountTargetSecurityGroupsCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyMountTargetSecurityGroupsCommand extends $Command<ModifyMountTargetSecurityGroupsCommandInput, ModifyMountTargetSecurityGroupsCommandOutput, EFSClientResolvedConfig> {
     readonly input: ModifyMountTargetSecurityGroupsCommandInput;
     constructor(input: ModifyMountTargetSecurityGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyMountTargetSecurityGroupsCommandInput, ModifyMountTargetSecurityGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface PutAccountPreferencesCommandInput extends PutAccountPreferences
 }
 export interface PutAccountPreferencesCommandOutput extends PutAccountPreferencesResponse, __MetadataBearer {
 }
-/**
- * <p>Use this operation to set the account preference in the current Amazon Web Services Region to use either long 17 character (63 bit) or short 8 character (32 bit) IDs for
- *       new EFS file systems and mount targets created. All existing resource IDs are not affected by any changes you make. You can set the ID preference during the
- *       opt-in period as EFS transitions to long resource IDs. For more information,
- *       see <a href="efs/latest/ug/manage-efs-resource-ids.html">Managing Amazon EFS resource IDs</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, PutAccountPreferencesCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, PutAccountPreferencesCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new PutAccountPreferencesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutAccountPreferencesCommandInput} for command's `input` shape.
- * @see {@link PutAccountPreferencesCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutAccountPreferencesCommand extends $Command<PutAccountPreferencesCommandInput, PutAccountPreferencesCommandOutput, EFSClientResolvedConfig> {
     readonly input: PutAccountPreferencesCommandInput;
     constructor(input: PutAccountPreferencesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAccountPreferencesCommandInput, PutAccountPreferencesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface PutBackupPolicyCommandInput extends PutBackupPolicyRequest {
 }
 export interface PutBackupPolicyCommandOutput extends BackupPolicyDescription, __MetadataBearer {
 }
-/**
- * <p>Updates the file system's backup policy. Use this action to start or stop automatic backups of the file system. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EFSClient, PutBackupPolicyCommand } from "@aws-sdk/client-efs"; // ES Modules import
- * // const { EFSClient, PutBackupPolicyCommand } = require("@aws-sdk/client-efs"); // CommonJS import
- * const client = new EFSClient(config);
- * const command = new PutBackupPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutBackupPolicyCommandInput} for command's `input` shape.
- * @see {@link PutBackupPolicyCommandOutput} for command's `response` shape.
- * @see {@link EFSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutBackupPolicyCommand extends $Command<PutBackupPolicyCommandInput, PutBackupPolicyCommandOutput, EFSClientResolvedConfig> {
     readonly input: PutBackupPolicyCommandInput;
     constructor(input: PutBackupPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EFSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutBackupPolicyCommandInput, PutBackupPolicyCommandOutput>;
     private serialize;
     private deserialize;