@aws-sdk/client-fsx 3.180.0 → 3.183.0

package/dist-es/FSx.js

@@ -1,10 +1,10 @@
-import { __extends } from "tslib";
 import { AssociateFileSystemAliasesCommand, } from "./commands/AssociateFileSystemAliasesCommand";
 import { CancelDataRepositoryTaskCommand, } from "./commands/CancelDataRepositoryTaskCommand";
 import { CopyBackupCommand } from "./commands/CopyBackupCommand";
 import { CreateBackupCommand, } from "./commands/CreateBackupCommand";
 import { CreateDataRepositoryAssociationCommand, } from "./commands/CreateDataRepositoryAssociationCommand";
 import { CreateDataRepositoryTaskCommand, } from "./commands/CreateDataRepositoryTaskCommand";
+import { CreateFileCacheCommand, } from "./commands/CreateFileCacheCommand";
 import { CreateFileSystemCommand, } from "./commands/CreateFileSystemCommand";
 import { CreateFileSystemFromBackupCommand, } from "./commands/CreateFileSystemFromBackupCommand";
 import { CreateSnapshotCommand, } from "./commands/CreateSnapshotCommand";
@@ -13,6 +13,7 @@ import { CreateVolumeCommand, } from "./commands/CreateVolumeCommand";
 import { CreateVolumeFromBackupCommand, } from "./commands/CreateVolumeFromBackupCommand";
 import { DeleteBackupCommand, } from "./commands/DeleteBackupCommand";
 import { DeleteDataRepositoryAssociationCommand, } from "./commands/DeleteDataRepositoryAssociationCommand";
+import { DeleteFileCacheCommand, } from "./commands/DeleteFileCacheCommand";
 import { DeleteFileSystemCommand, } from "./commands/DeleteFileSystemCommand";
 import { DeleteSnapshotCommand, } from "./commands/DeleteSnapshotCommand";
 import { DeleteStorageVirtualMachineCommand, } from "./commands/DeleteStorageVirtualMachineCommand";
@@ -20,6 +21,7 @@ import { DeleteVolumeCommand, } from "./commands/DeleteVolumeCommand";
 import { DescribeBackupsCommand, } from "./commands/DescribeBackupsCommand";
 import { DescribeDataRepositoryAssociationsCommand, } from "./commands/DescribeDataRepositoryAssociationsCommand";
 import { DescribeDataRepositoryTasksCommand, } from "./commands/DescribeDataRepositoryTasksCommand";
+import { DescribeFileCachesCommand, } from "./commands/DescribeFileCachesCommand";
 import { DescribeFileSystemAliasesCommand, } from "./commands/DescribeFileSystemAliasesCommand";
 import { DescribeFileSystemsCommand, } from "./commands/DescribeFileSystemsCommand";
 import { DescribeSnapshotsCommand, } from "./commands/DescribeSnapshotsCommand";
@@ -32,534 +34,585 @@ import { RestoreVolumeFromSnapshotCommand, } from "./commands/RestoreVolumeFromS
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateDataRepositoryAssociationCommand, } from "./commands/UpdateDataRepositoryAssociationCommand";
+import { UpdateFileCacheCommand, } from "./commands/UpdateFileCacheCommand";
 import { UpdateFileSystemCommand, } from "./commands/UpdateFileSystemCommand";
 import { UpdateSnapshotCommand, } from "./commands/UpdateSnapshotCommand";
 import { UpdateStorageVirtualMachineCommand, } from "./commands/UpdateStorageVirtualMachineCommand";
 import { UpdateVolumeCommand, } from "./commands/UpdateVolumeCommand";
 import { FSxClient } from "./FSxClient";
-var FSx = (function (_super) {
-    __extends(FSx, _super);
-    function FSx() {
-        return _super !== null && _super.apply(this, arguments) || this;
+export class FSx extends FSxClient {
+    associateFileSystemAliases(args, optionsOrCb, cb) {
+        const command = new AssociateFileSystemAliasesCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    cancelDataRepositoryTask(args, optionsOrCb, cb) {
+        const command = new CancelDataRepositoryTaskCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    copyBackup(args, optionsOrCb, cb) {
+        const command = new CopyBackupCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    createBackup(args, optionsOrCb, cb) {
+        const command = new CreateBackupCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
     }
-    FSx.prototype.associateFileSystemAliases = function (args, optionsOrCb, cb) {
-        var command = new AssociateFileSystemAliasesCommand(args);
+    createDataRepositoryAssociation(args, optionsOrCb, cb) {
+        const command = new CreateDataRepositoryAssociationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.cancelDataRepositoryTask = function (args, optionsOrCb, cb) {
-        var command = new CancelDataRepositoryTaskCommand(args);
+    }
+    createDataRepositoryTask(args, optionsOrCb, cb) {
+        const command = new CreateDataRepositoryTaskCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.copyBackup = function (args, optionsOrCb, cb) {
-        var command = new CopyBackupCommand(args);
+    }
+    createFileCache(args, optionsOrCb, cb) {
+        const command = new CreateFileCacheCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.createBackup = function (args, optionsOrCb, cb) {
-        var command = new CreateBackupCommand(args);
+    }
+    createFileSystem(args, optionsOrCb, cb) {
+        const command = new CreateFileSystemCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.createDataRepositoryAssociation = function (args, optionsOrCb, cb) {
-        var command = new CreateDataRepositoryAssociationCommand(args);
+    }
+    createFileSystemFromBackup(args, optionsOrCb, cb) {
+        const command = new CreateFileSystemFromBackupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.createDataRepositoryTask = function (args, optionsOrCb, cb) {
-        var command = new CreateDataRepositoryTaskCommand(args);
+    }
+    createSnapshot(args, optionsOrCb, cb) {
+        const command = new CreateSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.createFileSystem = function (args, optionsOrCb, cb) {
-        var command = new CreateFileSystemCommand(args);
+    }
+    createStorageVirtualMachine(args, optionsOrCb, cb) {
+        const command = new CreateStorageVirtualMachineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.createFileSystemFromBackup = function (args, optionsOrCb, cb) {
-        var command = new CreateFileSystemFromBackupCommand(args);
+    }
+    createVolume(args, optionsOrCb, cb) {
+        const command = new CreateVolumeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.createSnapshot = function (args, optionsOrCb, cb) {
-        var command = new CreateSnapshotCommand(args);
+    }
+    createVolumeFromBackup(args, optionsOrCb, cb) {
+        const command = new CreateVolumeFromBackupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.createStorageVirtualMachine = function (args, optionsOrCb, cb) {
-        var command = new CreateStorageVirtualMachineCommand(args);
+    }
+    deleteBackup(args, optionsOrCb, cb) {
+        const command = new DeleteBackupCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.createVolume = function (args, optionsOrCb, cb) {
-        var command = new CreateVolumeCommand(args);
+    }
+    deleteDataRepositoryAssociation(args, optionsOrCb, cb) {
+        const command = new DeleteDataRepositoryAssociationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.createVolumeFromBackup = function (args, optionsOrCb, cb) {
-        var command = new CreateVolumeFromBackupCommand(args);
+    }
+    deleteFileCache(args, optionsOrCb, cb) {
+        const command = new DeleteFileCacheCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.deleteBackup = function (args, optionsOrCb, cb) {
-        var command = new DeleteBackupCommand(args);
+    }
+    deleteFileSystem(args, optionsOrCb, cb) {
+        const command = new DeleteFileSystemCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.deleteDataRepositoryAssociation = function (args, optionsOrCb, cb) {
-        var command = new DeleteDataRepositoryAssociationCommand(args);
+    }
+    deleteSnapshot(args, optionsOrCb, cb) {
+        const command = new DeleteSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.deleteFileSystem = function (args, optionsOrCb, cb) {
-        var command = new DeleteFileSystemCommand(args);
+    }
+    deleteStorageVirtualMachine(args, optionsOrCb, cb) {
+        const command = new DeleteStorageVirtualMachineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.deleteSnapshot = function (args, optionsOrCb, cb) {
-        var command = new DeleteSnapshotCommand(args);
+    }
+    deleteVolume(args, optionsOrCb, cb) {
+        const command = new DeleteVolumeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.deleteStorageVirtualMachine = function (args, optionsOrCb, cb) {
-        var command = new DeleteStorageVirtualMachineCommand(args);
+    }
+    describeBackups(args, optionsOrCb, cb) {
+        const command = new DescribeBackupsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.deleteVolume = function (args, optionsOrCb, cb) {
-        var command = new DeleteVolumeCommand(args);
+    }
+    describeDataRepositoryAssociations(args, optionsOrCb, cb) {
+        const command = new DescribeDataRepositoryAssociationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.describeBackups = function (args, optionsOrCb, cb) {
-        var command = new DescribeBackupsCommand(args);
+    }
+    describeDataRepositoryTasks(args, optionsOrCb, cb) {
+        const command = new DescribeDataRepositoryTasksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.describeDataRepositoryAssociations = function (args, optionsOrCb, cb) {
-        var command = new DescribeDataRepositoryAssociationsCommand(args);
+    }
+    describeFileCaches(args, optionsOrCb, cb) {
+        const command = new DescribeFileCachesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.describeDataRepositoryTasks = function (args, optionsOrCb, cb) {
-        var command = new DescribeDataRepositoryTasksCommand(args);
+    }
+    describeFileSystemAliases(args, optionsOrCb, cb) {
+        const command = new DescribeFileSystemAliasesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.describeFileSystemAliases = function (args, optionsOrCb, cb) {
-        var command = new DescribeFileSystemAliasesCommand(args);
+    }
+    describeFileSystems(args, optionsOrCb, cb) {
+        const command = new DescribeFileSystemsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.describeFileSystems = function (args, optionsOrCb, cb) {
-        var command = new DescribeFileSystemsCommand(args);
+    }
+    describeSnapshots(args, optionsOrCb, cb) {
+        const command = new DescribeSnapshotsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.describeSnapshots = function (args, optionsOrCb, cb) {
-        var command = new DescribeSnapshotsCommand(args);
+    }
+    describeStorageVirtualMachines(args, optionsOrCb, cb) {
+        const command = new DescribeStorageVirtualMachinesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.describeStorageVirtualMachines = function (args, optionsOrCb, cb) {
-        var command = new DescribeStorageVirtualMachinesCommand(args);
+    }
+    describeVolumes(args, optionsOrCb, cb) {
+        const command = new DescribeVolumesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.describeVolumes = function (args, optionsOrCb, cb) {
-        var command = new DescribeVolumesCommand(args);
+    }
+    disassociateFileSystemAliases(args, optionsOrCb, cb) {
+        const command = new DisassociateFileSystemAliasesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.disassociateFileSystemAliases = function (args, optionsOrCb, cb) {
-        var command = new DisassociateFileSystemAliasesCommand(args);
+    }
+    listTagsForResource(args, optionsOrCb, cb) {
+        const command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
-        var command = new ListTagsForResourceCommand(args);
+    }
+    releaseFileSystemNfsV3Locks(args, optionsOrCb, cb) {
+        const command = new ReleaseFileSystemNfsV3LocksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.releaseFileSystemNfsV3Locks = function (args, optionsOrCb, cb) {
-        var command = new ReleaseFileSystemNfsV3LocksCommand(args);
+    }
+    restoreVolumeFromSnapshot(args, optionsOrCb, cb) {
+        const command = new RestoreVolumeFromSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.restoreVolumeFromSnapshot = function (args, optionsOrCb, cb) {
-        var command = new RestoreVolumeFromSnapshotCommand(args);
+    }
+    tagResource(args, optionsOrCb, cb) {
+        const command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.tagResource = function (args, optionsOrCb, cb) {
-        var command = new TagResourceCommand(args);
+    }
+    untagResource(args, optionsOrCb, cb) {
+        const command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.untagResource = function (args, optionsOrCb, cb) {
-        var command = new UntagResourceCommand(args);
+    }
+    updateDataRepositoryAssociation(args, optionsOrCb, cb) {
+        const command = new UpdateDataRepositoryAssociationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.updateDataRepositoryAssociation = function (args, optionsOrCb, cb) {
-        var command = new UpdateDataRepositoryAssociationCommand(args);
+    }
+    updateFileCache(args, optionsOrCb, cb) {
+        const command = new UpdateFileCacheCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.updateFileSystem = function (args, optionsOrCb, cb) {
-        var command = new UpdateFileSystemCommand(args);
+    }
+    updateFileSystem(args, optionsOrCb, cb) {
+        const command = new UpdateFileSystemCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.updateSnapshot = function (args, optionsOrCb, cb) {
-        var command = new UpdateSnapshotCommand(args);
+    }
+    updateSnapshot(args, optionsOrCb, cb) {
+        const command = new UpdateSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.updateStorageVirtualMachine = function (args, optionsOrCb, cb) {
-        var command = new UpdateStorageVirtualMachineCommand(args);
+    }
+    updateStorageVirtualMachine(args, optionsOrCb, cb) {
+        const command = new UpdateStorageVirtualMachineCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    FSx.prototype.updateVolume = function (args, optionsOrCb, cb) {
-        var command = new UpdateVolumeCommand(args);
+    }
+    updateVolume(args, optionsOrCb, cb) {
+        const command = new UpdateVolumeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    return FSx;
-}(FSxClient));
-export { FSx };
+    }
+}