@aws-sdk/client-fsx 3.35.0 → 3.38.0

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

@@ -6,37 +6,11 @@ export interface DeleteBackupCommandInput extends DeleteBackupRequest {
 }
 export interface DeleteBackupCommandOutput extends DeleteBackupResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes an Amazon FSx backup, deleting its contents. After deletion, the backup no longer exists, and its data is gone.</p>
- *
- *         <p>The <code>DeleteBackup</code> call returns instantly. The backup will not show up
- *             in later <code>DescribeBackups</code> calls.</p>
- *
- *         <important>
- *             <p>The data in a deleted backup is also deleted and can't be recovered by any
- *                 means.</p>
- *         </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FSxClient, DeleteBackupCommand } from "@aws-sdk/client-fsx"; // ES Modules import
- * // const { FSxClient, DeleteBackupCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
- * const client = new FSxClient(config);
- * const command = new DeleteBackupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteBackupCommandInput} for command's `input` shape.
- * @see {@link DeleteBackupCommandOutput} for command's `response` shape.
- * @see {@link FSxClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteBackupCommand extends $Command<DeleteBackupCommandInput, DeleteBackupCommandOutput, FSxClientResolvedConfig> {
     readonly input: DeleteBackupCommandInput;
     constructor(input: DeleteBackupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: FSxClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBackupCommandInput, DeleteBackupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,54 +6,11 @@ export interface DeleteFileSystemCommandInput extends DeleteFileSystemRequest {
 }
 export interface DeleteFileSystemCommandOutput extends DeleteFileSystemResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a file system, deleting its contents. After deletion, the file system no
- *             longer exists, and its data is gone. Any existing automatic backups will also be
- *             deleted.</p>
- *         <p>To delete an Amazon FSx for NetApp ONTAP file system, first delete all the volumes
- *             and SVMs on the file system. Then provide a <code>FileSystemId</code> value to the
- *             <code>DeleFileSystem</code> operation.</p>
- *
- *         <p>By default, when you delete an Amazon FSx for Windows File Server file system, a
- *             final backup is created upon deletion. This final backup is not subject to the file
- *             system's retention policy, and must be manually deleted.</p>
- *
- *         <p>The <code>DeleteFileSystem</code> action returns while the file system has the
- *                 <code>DELETING</code> status. You can check the file system deletion status by
- *             calling the <a>DescribeFileSystems</a> action, which returns a list of file
- *             systems in your account. If you pass the file system ID for a deleted file system, the
- *                 <a>DescribeFileSystems</a> returns a <code>FileSystemNotFound</code>
- *             error.</p>
- *         <note>
- *             <p>Deleting an Amazon FSx for Lustre file system will fail with a 400 BadRequest if
- *             a data repository task is in a <code>PENDING</code> or <code>EXECUTING</code>
- *             state.</p>
- *          </note>
- *         <important>
- *             <p>The data in a deleted file system is also deleted and can't be recovered by
- *                 any means.</p>
- *         </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FSxClient, DeleteFileSystemCommand } from "@aws-sdk/client-fsx"; // ES Modules import
- * // const { FSxClient, DeleteFileSystemCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
- * const client = new FSxClient(config);
- * const command = new DeleteFileSystemCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteFileSystemCommandInput} for command's `input` shape.
- * @see {@link DeleteFileSystemCommandOutput} for command's `response` shape.
- * @see {@link FSxClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteFileSystemCommand extends $Command<DeleteFileSystemCommandInput, DeleteFileSystemCommandOutput, FSxClientResolvedConfig> {
     readonly input: DeleteFileSystemCommandInput;
     constructor(input: DeleteFileSystemCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: FSxClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFileSystemCommandInput, DeleteFileSystemCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteStorageVirtualMachineCommandInput extends DeleteStorageVi
 }
 export interface DeleteStorageVirtualMachineCommandOutput extends DeleteStorageVirtualMachineResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes an existing Amazon FSx for ONTAP storage virtual machine (SVM). Prior
- *         to deleting an SVM, you must delete all non-root volumes in the SVM, otherwise the operation will fail.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FSxClient, DeleteStorageVirtualMachineCommand } from "@aws-sdk/client-fsx"; // ES Modules import
- * // const { FSxClient, DeleteStorageVirtualMachineCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
- * const client = new FSxClient(config);
- * const command = new DeleteStorageVirtualMachineCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteStorageVirtualMachineCommandInput} for command's `input` shape.
- * @see {@link DeleteStorageVirtualMachineCommandOutput} for command's `response` shape.
- * @see {@link FSxClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteStorageVirtualMachineCommand extends $Command<DeleteStorageVirtualMachineCommandInput, DeleteStorageVirtualMachineCommandOutput, FSxClientResolvedConfig> {
     readonly input: DeleteStorageVirtualMachineCommandInput;
     constructor(input: DeleteStorageVirtualMachineCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: FSxClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteStorageVirtualMachineCommandInput, DeleteStorageVirtualMachineCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteVolumeCommandInput extends DeleteVolumeRequest {
 }
 export interface DeleteVolumeCommandOutput extends DeleteVolumeResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes an Amazon FSx for NetApp ONTAP volume. When deleting a volume,
- *         you have the option of creating a final backup. If you create a final backup, you have the option to
- *         apply Tags to the backup. You need to have <code>fsx:TagResource</code>
- *             permission in order to apply tags to the backup.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FSxClient, DeleteVolumeCommand } from "@aws-sdk/client-fsx"; // ES Modules import
- * // const { FSxClient, DeleteVolumeCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
- * const client = new FSxClient(config);
- * const command = new DeleteVolumeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteVolumeCommandInput} for command's `input` shape.
- * @see {@link DeleteVolumeCommandOutput} for command's `response` shape.
- * @see {@link FSxClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteVolumeCommand extends $Command<DeleteVolumeCommandInput, DeleteVolumeCommandOutput, FSxClientResolvedConfig> {
     readonly input: DeleteVolumeCommandInput;
     constructor(input: DeleteVolumeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: FSxClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVolumeCommandInput, DeleteVolumeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,58 +6,11 @@ export interface DescribeBackupsCommandInput extends DescribeBackupsRequest {
 }
 export interface DescribeBackupsCommandOutput extends DescribeBackupsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the description of specific Amazon FSx backups, if
- *             a <code>BackupIds</code> value is provided for that backup. Otherwise, it returns all
- *             backups owned by your Amazon Web Services account  in the Amazon Web Services Region
- *             of the endpoint that you're calling.</p>
- *
- *         <p>When retrieving all backups, you can optionally specify the <code>MaxResults</code>
- *             parameter to limit the number of backups in a response. If more backups remain, Amazon
- *             FSx returns a <code>NextToken</code> value in the response. In this case, send a later
- *             request with the <code>NextToken</code> request parameter set to the value of
- *                 <code>NextToken</code> from the last response.</p>
- *
- *         <p>This action is used in an iterative process to retrieve a list of your backups.
- *                 <code>DescribeBackups</code> is called first without a <code>NextToken</code>value.
- *             Then the action continues to be called with the <code>NextToken</code> parameter set to
- *             the value of the last <code>NextToken</code> value until a response has no
- *                 <code>NextToken</code>.</p>
- *
- *         <p>When using this action, keep the following in mind:</p>
- *         <ul>
- *             <li>
- *                 <p>The implementation might return fewer than <code>MaxResults</code>
- *                     backup descriptions while still including a <code>NextToken</code>
- *                     value.</p>
- *             </li>
- *             <li>
- *                 <p>The order of backups returned in the response of one
- *                         <code>DescribeBackups</code> call and the order of backups returned across
- *                     the responses of a multi-call iteration is unspecified.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FSxClient, DescribeBackupsCommand } from "@aws-sdk/client-fsx"; // ES Modules import
- * // const { FSxClient, DescribeBackupsCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
- * const client = new FSxClient(config);
- * const command = new DescribeBackupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeBackupsCommandInput} for command's `input` shape.
- * @see {@link DescribeBackupsCommandOutput} for command's `response` shape.
- * @see {@link FSxClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeBackupsCommand extends $Command<DescribeBackupsCommandInput, DescribeBackupsCommandOutput, FSxClientResolvedConfig> {
     readonly input: DescribeBackupsCommandInput;
     constructor(input: DescribeBackupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: FSxClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeBackupsCommandInput, DescribeBackupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface DescribeDataRepositoryTasksCommandInput extends DescribeDataRep
 }
 export interface DescribeDataRepositoryTasksCommandOutput extends DescribeDataRepositoryTasksResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the description of specific Amazon FSx for Lustre data repository tasks, if
- *             one or more <code>TaskIds</code> values are provided in the request, or if filters are used in the request.
- *             You can use filters to narrow the response to include just tasks for specific file systems,
- *             or tasks in a specific lifecycle state. Otherwise, it returns all data repository tasks owned
- *             by your Amazon Web Services account in the Amazon Web Services Region of the endpoint that you're calling.</p>
- *
- *         <p>When retrieving all tasks, you can paginate the response by using  the optional <code>MaxResults</code>
- *             parameter to limit the number of tasks returned in a response. If more tasks remain, Amazon
- *             FSx returns a <code>NextToken</code> value in the response. In this case, send a later
- *             request with the <code>NextToken</code> request parameter set to the value of
- *             <code>NextToken</code> from the last response.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FSxClient, DescribeDataRepositoryTasksCommand } from "@aws-sdk/client-fsx"; // ES Modules import
- * // const { FSxClient, DescribeDataRepositoryTasksCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
- * const client = new FSxClient(config);
- * const command = new DescribeDataRepositoryTasksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDataRepositoryTasksCommandInput} for command's `input` shape.
- * @see {@link DescribeDataRepositoryTasksCommandOutput} for command's `response` shape.
- * @see {@link FSxClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDataRepositoryTasksCommand extends $Command<DescribeDataRepositoryTasksCommandInput, DescribeDataRepositoryTasksCommandOutput, FSxClientResolvedConfig> {
     readonly input: DescribeDataRepositoryTasksCommandInput;
     constructor(input: DescribeDataRepositoryTasksCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: FSxClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDataRepositoryTasksCommandInput, DescribeDataRepositoryTasksCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeFileSystemAliasesCommandInput extends DescribeFileSyste
 }
 export interface DescribeFileSystemAliasesCommandOutput extends DescribeFileSystemAliasesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the DNS aliases that are associated with the specified Amazon FSx for Windows File Server file system. A history of
- *             all DNS aliases that have been associated with and disassociated from the file system is available in the list of <a>AdministrativeAction</a>
- *         provided in the <a>DescribeFileSystems</a> operation response.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FSxClient, DescribeFileSystemAliasesCommand } from "@aws-sdk/client-fsx"; // ES Modules import
- * // const { FSxClient, DescribeFileSystemAliasesCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
- * const client = new FSxClient(config);
- * const command = new DescribeFileSystemAliasesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeFileSystemAliasesCommandInput} for command's `input` shape.
- * @see {@link DescribeFileSystemAliasesCommandOutput} for command's `response` shape.
- * @see {@link FSxClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeFileSystemAliasesCommand extends $Command<DescribeFileSystemAliasesCommandInput, DescribeFileSystemAliasesCommandOutput, FSxClientResolvedConfig> {
     readonly input: DescribeFileSystemAliasesCommandInput;
     constructor(input: DescribeFileSystemAliasesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: FSxClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFileSystemAliasesCommandInput, DescribeFileSystemAliasesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,60 +6,11 @@ export interface DescribeFileSystemsCommandInput extends DescribeFileSystemsRequ
 }
 export interface DescribeFileSystemsCommandOutput extends DescribeFileSystemsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the description of specific Amazon FSx file systems, if a
- *                 <code>FileSystemIds</code> value is provided for that file system. Otherwise, it
- *             returns descriptions of all file systems owned by your 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>MaxResults</code> parameter to limit the number of descriptions in a response.
- *             If more file system descriptions remain, Amazon FSx returns a <code>NextToken</code>
- *             value in the response. In this case, send a later request with the
- *                 <code>NextToken</code> request parameter set to the value of <code>NextToken</code>
- *             from the last response.</p>
- *
- *         <p>This action is used in an iterative process to retrieve a list of your file system
- *             descriptions. <code>DescribeFileSystems</code> is called first without a
- *                 <code>NextToken</code>value. Then the action continues to be called with the
- *                 <code>NextToken</code> parameter set to the value of the last <code>NextToken</code>
- *             value until a response has no <code>NextToken</code>.</p>
- *
- *         <p>When using this action, keep the following in mind:</p>
- *         <ul>
- *             <li>
- *                 <p>The implementation might return fewer than <code>MaxResults</code> file
- *                     system descriptions while still including a <code>NextToken</code>
- *                     value.</p>
- *
- *             </li>
- *             <li>
- *                 <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 multicall iteration is unspecified.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FSxClient, DescribeFileSystemsCommand } from "@aws-sdk/client-fsx"; // ES Modules import
- * // const { FSxClient, DescribeFileSystemsCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
- * const client = new FSxClient(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 FSxClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeFileSystemsCommand extends $Command<DescribeFileSystemsCommandInput, DescribeFileSystemsCommandOutput, FSxClientResolvedConfig> {
     readonly input: DescribeFileSystemsCommandInput;
     constructor(input: DescribeFileSystemsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: FSxClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFileSystemsCommandInput, DescribeFileSystemsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeStorageVirtualMachinesCommandInput extends DescribeStor
 }
 export interface DescribeStorageVirtualMachinesCommandOutput extends DescribeStorageVirtualMachinesResponse, __MetadataBearer {
 }
-/**
- * <p>Describes one or more Amazon FSx for NetApp ONTAP storage virtual machines (SVMs).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FSxClient, DescribeStorageVirtualMachinesCommand } from "@aws-sdk/client-fsx"; // ES Modules import
- * // const { FSxClient, DescribeStorageVirtualMachinesCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
- * const client = new FSxClient(config);
- * const command = new DescribeStorageVirtualMachinesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeStorageVirtualMachinesCommandInput} for command's `input` shape.
- * @see {@link DescribeStorageVirtualMachinesCommandOutput} for command's `response` shape.
- * @see {@link FSxClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeStorageVirtualMachinesCommand extends $Command<DescribeStorageVirtualMachinesCommandInput, DescribeStorageVirtualMachinesCommandOutput, FSxClientResolvedConfig> {
     readonly input: DescribeStorageVirtualMachinesCommandInput;
     constructor(input: DescribeStorageVirtualMachinesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: FSxClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStorageVirtualMachinesCommandInput, DescribeStorageVirtualMachinesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeVolumesCommandInput extends DescribeVolumesRequest {
 }
 export interface DescribeVolumesCommandOutput extends DescribeVolumesResponse, __MetadataBearer {
 }
-/**
- * <p>Describes one or more Amazon FSx for NetApp ONTAP volumes.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FSxClient, DescribeVolumesCommand } from "@aws-sdk/client-fsx"; // ES Modules import
- * // const { FSxClient, DescribeVolumesCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
- * const client = new FSxClient(config);
- * const command = new DescribeVolumesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeVolumesCommandInput} for command's `input` shape.
- * @see {@link DescribeVolumesCommandOutput} for command's `response` shape.
- * @see {@link FSxClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeVolumesCommand extends $Command<DescribeVolumesCommandInput, DescribeVolumesCommandOutput, FSxClientResolvedConfig> {
     readonly input: DescribeVolumesCommandInput;
     constructor(input: DescribeVolumesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: FSxClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeVolumesCommandInput, DescribeVolumesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface DisassociateFileSystemAliasesCommandInput extends DisassociateF
 }
 export interface DisassociateFileSystemAliasesCommandOutput extends DisassociateFileSystemAliasesResponse, __MetadataBearer {
 }
-/**
- * <p>Use this action to disassociate, or remove, one or more Domain Name Service (DNS) aliases
- *             from an Amazon FSx for Windows File Server file system. If you attempt to disassociate a DNS alias that is not
- *             associated with the file system, Amazon FSx responds with a 400 Bad Request. For more information, see
- *             <a href="https://docs.aws.amazon.com/fsx/latest/WindowsGuide/managing-dns-aliases.html">Working with DNS Aliases</a>.</p>
- *         <p>The system generated response showing the DNS aliases that
- *             Amazon FSx is attempting to disassociate from the file system.
- *             Use the  API
- *             operation to monitor the status of the aliases Amazon FSx is
- *             disassociating with the file system.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FSxClient, DisassociateFileSystemAliasesCommand } from "@aws-sdk/client-fsx"; // ES Modules import
- * // const { FSxClient, DisassociateFileSystemAliasesCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
- * const client = new FSxClient(config);
- * const command = new DisassociateFileSystemAliasesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisassociateFileSystemAliasesCommandInput} for command's `input` shape.
- * @see {@link DisassociateFileSystemAliasesCommandOutput} for command's `response` shape.
- * @see {@link FSxClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisassociateFileSystemAliasesCommand extends $Command<DisassociateFileSystemAliasesCommandInput, DisassociateFileSystemAliasesCommandOutput, FSxClientResolvedConfig> {
     readonly input: DisassociateFileSystemAliasesCommandInput;
     constructor(input: DisassociateFileSystemAliasesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: FSxClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateFileSystemAliasesCommandInput, DisassociateFileSystemAliasesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,57 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Lists tags for an Amazon FSx file systems and backups in the case of Amazon FSx for
- *             Windows File Server.</p>
- *
- *         <p>When retrieving all tags, you can optionally specify the <code>MaxResults</code>
- *             parameter to limit the number of tags in a response. If more tags remain, Amazon FSx
- *             returns a <code>NextToken</code> value in the response. In this case, send a later
- *             request with the <code>NextToken</code> request parameter set to the value of
- *                 <code>NextToken</code> from the last response.</p>
- *
- *         <p>This action is used in an iterative process to retrieve a list of your tags.
- *                 <code>ListTagsForResource</code> is called first without a
- *             <code>NextToken</code>value. Then the action continues to be called with the
- *                 <code>NextToken</code> parameter set to the value of the last <code>NextToken</code>
- *             value until a response has no <code>NextToken</code>.</p>
- *
- *         <p>When using this action, keep the following in mind:</p>
- *         <ul>
- *             <li>
- *                 <p>The implementation might return fewer than <code>MaxResults</code> file
- *                     system descriptions while still including a <code>NextToken</code>
- *                     value.</p>
- *
- *             </li>
- *             <li>
- *                 <p>The order of tags returned in the response of one
- *                         <code>ListTagsForResource</code> call and the order of tags returned across
- *                     the responses of a multi-call iteration is unspecified.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { FSxClient, ListTagsForResourceCommand } from "@aws-sdk/client-fsx"; // ES Modules import
- * // const { FSxClient, ListTagsForResourceCommand } = require("@aws-sdk/client-fsx"); // CommonJS import
- * const client = new FSxClient(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 FSxClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, FSxClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: FSxClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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