@aws-sdk/client-lightsail 3.32.0 → 3.36.0

package/dist-cjs/commands/StopInstanceCommand.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopInstanceCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Stops a specific Amazon Lightsail instance that is currently running.</p>
+ *          <note>
+ *             <p>When you start a stopped instance, Lightsail assigns a new public IP address to the
+ *         instance. To use the same IP address after stopping and starting an instance, create a
+ *         static IP address and attach it to the instance. For more information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/lightsail-create-static-ip">Amazon Lightsail Developer Guide</a>.</p>
+ *          </note>
+ *          <p>The <code>stop instance</code> operation supports tag-based access control via resource
+ *       tags applied to the resource identified by <code>instance name</code>. For more information,
+ *       see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, StopInstanceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, StopInstanceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new StopInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StopInstanceCommandInput} for command's `input` shape.
+ * @see {@link StopInstanceCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class StopInstanceCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_1_1.StopInstanceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.StopInstanceResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1StopInstanceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1StopInstanceCommand(output, context);
+    }
+}
+exports.StopInstanceCommand = StopInstanceCommand;

package/dist-cjs/commands/StopRelationalDatabaseCommand.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopRelationalDatabaseCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Stops a specific database that is currently running in Amazon Lightsail.</p>
+ *          <p>The <code>stop relational database</code> operation supports tag-based access control via
+ *       resource tags applied to the resource identified by relationalDatabaseName. For more
+ *       information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, StopRelationalDatabaseCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, StopRelationalDatabaseCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new StopRelationalDatabaseCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StopRelationalDatabaseCommandInput} for command's `input` shape.
+ * @see {@link StopRelationalDatabaseCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class StopRelationalDatabaseCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_1_1.StopRelationalDatabaseRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.StopRelationalDatabaseResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1StopRelationalDatabaseCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1StopRelationalDatabaseCommand(output, context);
+    }
+}
+exports.StopRelationalDatabaseCommand = StopRelationalDatabaseCommand;

package/dist-cjs/commands/TagResourceCommand.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagResourceCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Adds one or more tags to the specified Amazon Lightsail resource. Each resource can have a
+ *       maximum of 50 tags. Each tag consists of a key and an optional value. Tag keys must be unique
+ *       per resource. For more information about tags, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-tags">Amazon Lightsail Developer Guide</a>.</p>
+ *          <p>The <code>tag resource</code> operation supports tag-based access control via request tags
+ *       and resource tags applied to the resource identified by <code>resource name</code>. For more
+ *       information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, TagResourceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, TagResourceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class TagResourceCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_1_1.TagResourceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.TagResourceResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1TagResourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1TagResourceCommand(output, context);
+    }
+}
+exports.TagResourceCommand = TagResourceCommand;

package/dist-cjs/commands/TestAlarmCommand.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestAlarmCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Tests an alarm by displaying a banner on the Amazon Lightsail console. If a notification
+ *       trigger is configured for the specified alarm, the test also sends a notification to the
+ *       notification protocol (<code>Email</code> and/or <code>SMS</code>) configured for the
+ *       alarm.</p>
+ *          <p>An alarm is used to monitor a single metric for one of your resources. When a metric
+ *       condition is met, the alarm can notify you by email, SMS text message, and a banner displayed
+ *       on the Amazon Lightsail console. For more information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-alarms">Alarms
+ *         in Amazon Lightsail</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, TestAlarmCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, TestAlarmCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new TestAlarmCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TestAlarmCommandInput} for command's `input` shape.
+ * @see {@link TestAlarmCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class TestAlarmCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_1_1.TestAlarmRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.TestAlarmResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1TestAlarmCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1TestAlarmCommand(output, context);
+    }
+}
+exports.TestAlarmCommand = TestAlarmCommand;

package/dist-cjs/commands/UnpeerVpcCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnpeerVpcCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Unpeers the Lightsail VPC from the user's default VPC.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, UnpeerVpcCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, UnpeerVpcCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new UnpeerVpcCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UnpeerVpcCommandInput} for command's `input` shape.
+ * @see {@link UnpeerVpcCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class UnpeerVpcCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_1_1.UnpeerVpcRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.UnpeerVpcResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1UnpeerVpcCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1UnpeerVpcCommand(output, context);
+    }
+}
+exports.UnpeerVpcCommand = UnpeerVpcCommand;

package/dist-cjs/commands/UntagResourceCommand.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UntagResourceCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Deletes the specified set of tag keys and their values from the specified Amazon Lightsail
+ *       resource.</p>
+ *          <p>The <code>untag resource</code> operation supports tag-based access control via request
+ *       tags and resource tags applied to the resource identified by <code>resource name</code>. For
+ *       more information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, UntagResourceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, UntagResourceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new UntagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UntagResourceCommandInput} for command's `input` shape.
+ * @see {@link UntagResourceCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class UntagResourceCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_1_1.UntagResourceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.UntagResourceResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1UntagResourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1UntagResourceCommand(output, context);
+    }
+}
+exports.UntagResourceCommand = UntagResourceCommand;

package/dist-cjs/commands/UpdateBucketBundleCommand.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateBucketBundleCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Updates the bundle, or storage plan, of an existing Amazon Lightsail bucket.</p>
+ *
+ *          <p>A bucket bundle specifies the monthly cost, storage space, and data transfer quota for a
+ *       bucket. You can update a bucket's bundle only one time within a monthly AWS billing cycle. To
+ *       determine if you can update a bucket's bundle, use the <a>GetBuckets</a> action.
+ *       The <code>ableToUpdateBundle</code> parameter in the response will indicate whether you can
+ *       currently update a bucket's bundle.</p>
+ *
+ *          <p>Update a bucket's bundle if it's consistently going over its storage space or data
+ *       transfer quota, or if a bucket's usage is consistently in the lower range of its storage space
+ *       or data transfer quota. Due to the unpredictable usage fluctuations that a bucket might
+ *       experience, we strongly recommend that you update a bucket's bundle only as a long-term
+ *       strategy, instead of as a short-term, monthly cost-cutting measure. Choose a bucket bundle
+ *       that will provide the bucket with ample storage space and data transfer for a long time to
+ *       come.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, UpdateBucketBundleCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, UpdateBucketBundleCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new UpdateBucketBundleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateBucketBundleCommandInput} for command's `input` shape.
+ * @see {@link UpdateBucketBundleCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class UpdateBucketBundleCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_1_1.UpdateBucketBundleRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.UpdateBucketBundleResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1UpdateBucketBundleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1UpdateBucketBundleCommand(output, context);
+    }
+}
+exports.UpdateBucketBundleCommand = UpdateBucketBundleCommand;

package/dist-cjs/commands/UpdateBucketCommand.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateBucketCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Updates an existing Amazon Lightsail bucket.</p>
+ *
+ *          <p>Use this action to update the configuration of an existing bucket, such as versioning,
+ *       public accessibility, and the AWS accounts that can access the bucket.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, UpdateBucketCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, UpdateBucketCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new UpdateBucketCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateBucketCommandInput} for command's `input` shape.
+ * @see {@link UpdateBucketCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class UpdateBucketCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_1_1.UpdateBucketRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.UpdateBucketResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1UpdateBucketCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1UpdateBucketCommand(output, context);
+    }
+}
+exports.UpdateBucketCommand = UpdateBucketCommand;

package/dist-cjs/commands/UpdateContainerServiceCommand.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateContainerServiceCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Updates the configuration of your Amazon Lightsail container service, such as its power,
+ *       scale, and public domain names.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, UpdateContainerServiceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, UpdateContainerServiceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new UpdateContainerServiceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateContainerServiceCommandInput} for command's `input` shape.
+ * @see {@link UpdateContainerServiceCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class UpdateContainerServiceCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_1_1.UpdateContainerServiceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.UpdateContainerServiceResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1UpdateContainerServiceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1UpdateContainerServiceCommand(output, context);
+    }
+}
+exports.UpdateContainerServiceCommand = UpdateContainerServiceCommand;

package/dist-cjs/commands/UpdateDistributionBundleCommand.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateDistributionBundleCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Updates the bundle of your Amazon Lightsail content delivery network (CDN)
+ *       distribution.</p>
+ *          <p>A distribution bundle specifies the monthly network transfer quota and monthly cost of
+ *       your dsitribution.</p>
+ *          <p>Update your distribution's bundle if your distribution is going over its monthly network
+ *       transfer quota and is incurring an overage fee.</p>
+ *          <p>You can update your distribution's bundle only one time within your monthly AWS billing
+ *       cycle. To determine if you can update your distribution's bundle, use the
+ *         <code>GetDistributions</code> action. The <code>ableToUpdateBundle</code> parameter in the
+ *       result will indicate whether you can currently update your distribution's bundle.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, UpdateDistributionBundleCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, UpdateDistributionBundleCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new UpdateDistributionBundleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateDistributionBundleCommandInput} for command's `input` shape.
+ * @see {@link UpdateDistributionBundleCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class UpdateDistributionBundleCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_1_1.UpdateDistributionBundleRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.UpdateDistributionBundleResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1UpdateDistributionBundleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1UpdateDistributionBundleCommand(output, context);
+    }
+}
+exports.UpdateDistributionBundleCommand = UpdateDistributionBundleCommand;