@aws-sdk/client-lightsail 3.180.0 → 3.183.0

package/dist-es/commands/CreateBucketCommand.js

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

package/dist-es/commands/CreateCertificateCommand.js

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

package/dist-es/commands/CreateCloudFormationStackCommand.js

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

package/dist-es/commands/CreateContactMethodCommand.js

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

package/dist-es/commands/CreateContainerServiceCommand.js

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

package/dist-es/commands/CreateContainerServiceDeploymentCommand.js

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

package/dist-es/commands/CreateContainerServiceRegistryLoginCommand.js

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

package/dist-es/commands/CreateDiskCommand.js

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

package/dist-es/commands/CreateDiskFromSnapshotCommand.js

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

package/dist-es/commands/CreateDiskSnapshotCommand.js

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