@aws-sdk/client-lightsail 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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