@aws-sdk/client-lightsail 3.183.0 → 3.185.0

package/dist-es/commands/CreateBucketCommand.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 { CreateBucketRequestFilterSensitiveLog, CreateBucketResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateBucketCommand, serializeAws_json1_1CreateBucketCommand, } from "../protocols/Aws_json1_1";
-export class CreateBucketCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateBucketCommand = (function (_super) {
+    __extends(CreateBucketCommand, _super);
+    function CreateBucketCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateBucketCommand.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 = "LightsailClient";
-        const commandName = "CreateBucketCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "CreateBucketCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateBucketRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateBucketResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateBucketCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateBucketCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateBucketCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateBucketCommand(output, context);
-    }
-}
+    };
+    return CreateBucketCommand;
+}($Command));
+export { CreateBucketCommand };

package/dist-es/commands/CreateCertificateCommand.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 { CreateCertificateRequestFilterSensitiveLog, CreateCertificateResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateCertificateCommand, serializeAws_json1_1CreateCertificateCommand, } from "../protocols/Aws_json1_1";
-export class CreateCertificateCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateCertificateCommand = (function (_super) {
+    __extends(CreateCertificateCommand, _super);
+    function CreateCertificateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateCertificateCommand.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 = "LightsailClient";
-        const commandName = "CreateCertificateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "CreateCertificateCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateCertificateRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateCertificateResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateCertificateCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateCertificateCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateCertificateCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateCertificateCommand(output, context);
-    }
-}
+    };
+    return CreateCertificateCommand;
+}($Command));
+export { CreateCertificateCommand };

package/dist-es/commands/CreateCloudFormationStackCommand.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 { CreateCloudFormationStackRequestFilterSensitiveLog, CreateCloudFormationStackResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateCloudFormationStackCommand, serializeAws_json1_1CreateCloudFormationStackCommand, } from "../protocols/Aws_json1_1";
-export class CreateCloudFormationStackCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateCloudFormationStackCommand = (function (_super) {
+    __extends(CreateCloudFormationStackCommand, _super);
+    function CreateCloudFormationStackCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateCloudFormationStackCommand.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 = "LightsailClient";
-        const commandName = "CreateCloudFormationStackCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "CreateCloudFormationStackCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateCloudFormationStackRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateCloudFormationStackResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateCloudFormationStackCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateCloudFormationStackCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateCloudFormationStackCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateCloudFormationStackCommand(output, context);
-    }
-}
+    };
+    return CreateCloudFormationStackCommand;
+}($Command));
+export { CreateCloudFormationStackCommand };

package/dist-es/commands/CreateContactMethodCommand.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 { CreateContactMethodRequestFilterSensitiveLog, CreateContactMethodResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateContactMethodCommand, serializeAws_json1_1CreateContactMethodCommand, } from "../protocols/Aws_json1_1";
-export class CreateContactMethodCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateContactMethodCommand = (function (_super) {
+    __extends(CreateContactMethodCommand, _super);
+    function CreateContactMethodCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateContactMethodCommand.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 = "LightsailClient";
-        const commandName = "CreateContactMethodCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "CreateContactMethodCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateContactMethodRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateContactMethodResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateContactMethodCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateContactMethodCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateContactMethodCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateContactMethodCommand(output, context);
-    }
-}
+    };
+    return CreateContactMethodCommand;
+}($Command));
+export { CreateContactMethodCommand };

package/dist-es/commands/CreateContainerServiceCommand.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 { CreateContainerServiceRequestFilterSensitiveLog, CreateContainerServiceResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateContainerServiceCommand, serializeAws_json1_1CreateContainerServiceCommand, } from "../protocols/Aws_json1_1";
-export class CreateContainerServiceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateContainerServiceCommand = (function (_super) {
+    __extends(CreateContainerServiceCommand, _super);
+    function CreateContainerServiceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateContainerServiceCommand.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 = "LightsailClient";
-        const commandName = "CreateContainerServiceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "CreateContainerServiceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateContainerServiceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateContainerServiceResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateContainerServiceCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateContainerServiceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateContainerServiceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateContainerServiceCommand(output, context);
-    }
-}
+    };
+    return CreateContainerServiceCommand;
+}($Command));
+export { CreateContainerServiceCommand };

package/dist-es/commands/CreateContainerServiceDeploymentCommand.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 { CreateContainerServiceDeploymentRequestFilterSensitiveLog, CreateContainerServiceDeploymentResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateContainerServiceDeploymentCommand, serializeAws_json1_1CreateContainerServiceDeploymentCommand, } from "../protocols/Aws_json1_1";
-export class CreateContainerServiceDeploymentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateContainerServiceDeploymentCommand = (function (_super) {
+    __extends(CreateContainerServiceDeploymentCommand, _super);
+    function CreateContainerServiceDeploymentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateContainerServiceDeploymentCommand.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 = "LightsailClient";
-        const commandName = "CreateContainerServiceDeploymentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "CreateContainerServiceDeploymentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateContainerServiceDeploymentRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateContainerServiceDeploymentResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateContainerServiceDeploymentCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateContainerServiceDeploymentCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateContainerServiceDeploymentCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateContainerServiceDeploymentCommand(output, context);
-    }
-}
+    };
+    return CreateContainerServiceDeploymentCommand;
+}($Command));
+export { CreateContainerServiceDeploymentCommand };

package/dist-es/commands/CreateContainerServiceRegistryLoginCommand.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 { CreateContainerServiceRegistryLoginRequestFilterSensitiveLog, CreateContainerServiceRegistryLoginResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateContainerServiceRegistryLoginCommand, serializeAws_json1_1CreateContainerServiceRegistryLoginCommand, } from "../protocols/Aws_json1_1";
-export class CreateContainerServiceRegistryLoginCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateContainerServiceRegistryLoginCommand = (function (_super) {
+    __extends(CreateContainerServiceRegistryLoginCommand, _super);
+    function CreateContainerServiceRegistryLoginCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateContainerServiceRegistryLoginCommand.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 = "LightsailClient";
-        const commandName = "CreateContainerServiceRegistryLoginCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "CreateContainerServiceRegistryLoginCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateContainerServiceRegistryLoginRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateContainerServiceRegistryLoginResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateContainerServiceRegistryLoginCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateContainerServiceRegistryLoginCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateContainerServiceRegistryLoginCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateContainerServiceRegistryLoginCommand(output, context);
-    }
-}
+    };
+    return CreateContainerServiceRegistryLoginCommand;
+}($Command));
+export { CreateContainerServiceRegistryLoginCommand };

package/dist-es/commands/CreateDiskCommand.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 { CreateDiskRequestFilterSensitiveLog, CreateDiskResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateDiskCommand, serializeAws_json1_1CreateDiskCommand, } from "../protocols/Aws_json1_1";
-export class CreateDiskCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateDiskCommand = (function (_super) {
+    __extends(CreateDiskCommand, _super);
+    function CreateDiskCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateDiskCommand.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 = "LightsailClient";
-        const commandName = "CreateDiskCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "CreateDiskCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateDiskRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDiskResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateDiskCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateDiskCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateDiskCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateDiskCommand(output, context);
-    }
-}
+    };
+    return CreateDiskCommand;
+}($Command));
+export { CreateDiskCommand };

package/dist-es/commands/CreateDiskFromSnapshotCommand.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 { CreateDiskFromSnapshotRequestFilterSensitiveLog, CreateDiskFromSnapshotResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateDiskFromSnapshotCommand, serializeAws_json1_1CreateDiskFromSnapshotCommand, } from "../protocols/Aws_json1_1";
-export class CreateDiskFromSnapshotCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateDiskFromSnapshotCommand = (function (_super) {
+    __extends(CreateDiskFromSnapshotCommand, _super);
+    function CreateDiskFromSnapshotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateDiskFromSnapshotCommand.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 = "LightsailClient";
-        const commandName = "CreateDiskFromSnapshotCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "CreateDiskFromSnapshotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateDiskFromSnapshotRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDiskFromSnapshotResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateDiskFromSnapshotCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateDiskFromSnapshotCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateDiskFromSnapshotCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateDiskFromSnapshotCommand(output, context);
-    }
-}
+    };
+    return CreateDiskFromSnapshotCommand;
+}($Command));
+export { CreateDiskFromSnapshotCommand };

package/dist-es/commands/CreateDiskSnapshotCommand.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 { CreateDiskSnapshotRequestFilterSensitiveLog, CreateDiskSnapshotResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateDiskSnapshotCommand, serializeAws_json1_1CreateDiskSnapshotCommand, } from "../protocols/Aws_json1_1";
-export class CreateDiskSnapshotCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateDiskSnapshotCommand = (function (_super) {
+    __extends(CreateDiskSnapshotCommand, _super);
+    function CreateDiskSnapshotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateDiskSnapshotCommand.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 = "LightsailClient";
-        const commandName = "CreateDiskSnapshotCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "CreateDiskSnapshotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateDiskSnapshotRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDiskSnapshotResultFilterSensitiveLog,
         };
-        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);
+    };
+    CreateDiskSnapshotCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1CreateDiskSnapshotCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateDiskSnapshotCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateDiskSnapshotCommand(output, context);
-    }
-}
+    };
+    return CreateDiskSnapshotCommand;
+}($Command));
+export { CreateDiskSnapshotCommand };