@aws-sdk/client-fsx 3.183.0 → 3.185.0

package/dist-es/commands/CreateSnapshotCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateSnapshotRequestFilterSensitiveLog, CreateSnapshotResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateSnapshotCommand, serializeAws_json1_1CreateSnapshotCommand, } from "../protocols/Aws_json1_1";
-export class CreateSnapshotCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateSnapshotCommand = (function (_super) {
+    __extends(CreateSnapshotCommand, _super);
+    function CreateSnapshotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateSnapshotCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FSxClient";
-        const commandName = "CreateSnapshotCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FSxClient";
+        var commandName = "CreateSnapshotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateSnapshotRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateSnapshotResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateSnapshotCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateSnapshotCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateSnapshotCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateSnapshotCommand(output, context);
-    }
-}
+    };
+    return CreateSnapshotCommand;
+}($Command));
+export { CreateSnapshotCommand };

package/dist-es/commands/CreateStorageVirtualMachineCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateStorageVirtualMachineRequestFilterSensitiveLog, CreateStorageVirtualMachineResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateStorageVirtualMachineCommand, serializeAws_json1_1CreateStorageVirtualMachineCommand, } from "../protocols/Aws_json1_1";
-export class CreateStorageVirtualMachineCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateStorageVirtualMachineCommand = (function (_super) {
+    __extends(CreateStorageVirtualMachineCommand, _super);
+    function CreateStorageVirtualMachineCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateStorageVirtualMachineCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FSxClient";
-        const commandName = "CreateStorageVirtualMachineCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FSxClient";
+        var commandName = "CreateStorageVirtualMachineCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateStorageVirtualMachineRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateStorageVirtualMachineResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateStorageVirtualMachineCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateStorageVirtualMachineCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateStorageVirtualMachineCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateStorageVirtualMachineCommand(output, context);
-    }
-}
+    };
+    return CreateStorageVirtualMachineCommand;
+}($Command));
+export { CreateStorageVirtualMachineCommand };

package/dist-es/commands/CreateVolumeCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateVolumeRequestFilterSensitiveLog, CreateVolumeResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateVolumeCommand, serializeAws_json1_1CreateVolumeCommand, } from "../protocols/Aws_json1_1";
-export class CreateVolumeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateVolumeCommand = (function (_super) {
+    __extends(CreateVolumeCommand, _super);
+    function CreateVolumeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateVolumeCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FSxClient";
-        const commandName = "CreateVolumeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FSxClient";
+        var commandName = "CreateVolumeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateVolumeRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateVolumeResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateVolumeCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateVolumeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateVolumeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateVolumeCommand(output, context);
-    }
-}
+    };
+    return CreateVolumeCommand;
+}($Command));
+export { CreateVolumeCommand };

package/dist-es/commands/CreateVolumeFromBackupCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateVolumeFromBackupRequestFilterSensitiveLog, CreateVolumeFromBackupResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateVolumeFromBackupCommand, serializeAws_json1_1CreateVolumeFromBackupCommand, } from "../protocols/Aws_json1_1";
-export class CreateVolumeFromBackupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateVolumeFromBackupCommand = (function (_super) {
+    __extends(CreateVolumeFromBackupCommand, _super);
+    function CreateVolumeFromBackupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateVolumeFromBackupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FSxClient";
-        const commandName = "CreateVolumeFromBackupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FSxClient";
+        var commandName = "CreateVolumeFromBackupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateVolumeFromBackupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateVolumeFromBackupResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateVolumeFromBackupCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateVolumeFromBackupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateVolumeFromBackupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateVolumeFromBackupCommand(output, context);
-    }
-}
+    };
+    return CreateVolumeFromBackupCommand;
+}($Command));
+export { CreateVolumeFromBackupCommand };

package/dist-es/commands/DeleteBackupCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteBackupRequestFilterSensitiveLog, DeleteBackupResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteBackupCommand, serializeAws_json1_1DeleteBackupCommand, } from "../protocols/Aws_json1_1";
-export class DeleteBackupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteBackupCommand = (function (_super) {
+    __extends(DeleteBackupCommand, _super);
+    function DeleteBackupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteBackupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FSxClient";
-        const commandName = "DeleteBackupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FSxClient";
+        var commandName = "DeleteBackupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteBackupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteBackupResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteBackupCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteBackupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteBackupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteBackupCommand(output, context);
-    }
-}
+    };
+    return DeleteBackupCommand;
+}($Command));
+export { DeleteBackupCommand };

package/dist-es/commands/DeleteDataRepositoryAssociationCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteDataRepositoryAssociationRequestFilterSensitiveLog, DeleteDataRepositoryAssociationResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteDataRepositoryAssociationCommand, serializeAws_json1_1DeleteDataRepositoryAssociationCommand, } from "../protocols/Aws_json1_1";
-export class DeleteDataRepositoryAssociationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteDataRepositoryAssociationCommand = (function (_super) {
+    __extends(DeleteDataRepositoryAssociationCommand, _super);
+    function DeleteDataRepositoryAssociationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteDataRepositoryAssociationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FSxClient";
-        const commandName = "DeleteDataRepositoryAssociationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FSxClient";
+        var commandName = "DeleteDataRepositoryAssociationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteDataRepositoryAssociationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteDataRepositoryAssociationResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteDataRepositoryAssociationCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteDataRepositoryAssociationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteDataRepositoryAssociationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteDataRepositoryAssociationCommand(output, context);
-    }
-}
+    };
+    return DeleteDataRepositoryAssociationCommand;
+}($Command));
+export { DeleteDataRepositoryAssociationCommand };

package/dist-es/commands/DeleteFileCacheCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteFileCacheRequestFilterSensitiveLog, DeleteFileCacheResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteFileCacheCommand, serializeAws_json1_1DeleteFileCacheCommand, } from "../protocols/Aws_json1_1";
-export class DeleteFileCacheCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteFileCacheCommand = (function (_super) {
+    __extends(DeleteFileCacheCommand, _super);
+    function DeleteFileCacheCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteFileCacheCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FSxClient";
-        const commandName = "DeleteFileCacheCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FSxClient";
+        var commandName = "DeleteFileCacheCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteFileCacheRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteFileCacheResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteFileCacheCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteFileCacheCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteFileCacheCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteFileCacheCommand(output, context);
-    }
-}
+    };
+    return DeleteFileCacheCommand;
+}($Command));
+export { DeleteFileCacheCommand };

package/dist-es/commands/DeleteFileSystemCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteFileSystemRequestFilterSensitiveLog, DeleteFileSystemResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteFileSystemCommand, serializeAws_json1_1DeleteFileSystemCommand, } from "../protocols/Aws_json1_1";
-export class DeleteFileSystemCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteFileSystemCommand = (function (_super) {
+    __extends(DeleteFileSystemCommand, _super);
+    function DeleteFileSystemCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteFileSystemCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FSxClient";
-        const commandName = "DeleteFileSystemCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FSxClient";
+        var commandName = "DeleteFileSystemCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteFileSystemRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteFileSystemResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteFileSystemCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteFileSystemCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteFileSystemCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteFileSystemCommand(output, context);
-    }
-}
+    };
+    return DeleteFileSystemCommand;
+}($Command));
+export { DeleteFileSystemCommand };

package/dist-es/commands/DeleteSnapshotCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteSnapshotRequestFilterSensitiveLog, DeleteSnapshotResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteSnapshotCommand, serializeAws_json1_1DeleteSnapshotCommand, } from "../protocols/Aws_json1_1";
-export class DeleteSnapshotCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteSnapshotCommand = (function (_super) {
+    __extends(DeleteSnapshotCommand, _super);
+    function DeleteSnapshotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteSnapshotCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FSxClient";
-        const commandName = "DeleteSnapshotCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FSxClient";
+        var commandName = "DeleteSnapshotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteSnapshotRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteSnapshotResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteSnapshotCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteSnapshotCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteSnapshotCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteSnapshotCommand(output, context);
-    }
-}
+    };
+    return DeleteSnapshotCommand;
+}($Command));
+export { DeleteSnapshotCommand };

package/dist-es/commands/DeleteStorageVirtualMachineCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteStorageVirtualMachineRequestFilterSensitiveLog, DeleteStorageVirtualMachineResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteStorageVirtualMachineCommand, serializeAws_json1_1DeleteStorageVirtualMachineCommand, } from "../protocols/Aws_json1_1";
-export class DeleteStorageVirtualMachineCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteStorageVirtualMachineCommand = (function (_super) {
+    __extends(DeleteStorageVirtualMachineCommand, _super);
+    function DeleteStorageVirtualMachineCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteStorageVirtualMachineCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FSxClient";
-        const commandName = "DeleteStorageVirtualMachineCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FSxClient";
+        var commandName = "DeleteStorageVirtualMachineCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteStorageVirtualMachineRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteStorageVirtualMachineResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteStorageVirtualMachineCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteStorageVirtualMachineCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteStorageVirtualMachineCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteStorageVirtualMachineCommand(output, context);
-    }
-}
+    };
+    return DeleteStorageVirtualMachineCommand;
+}($Command));
+export { DeleteStorageVirtualMachineCommand };