@aws-sdk/client-lightsail 3.32.0 → 3.36.0

package/dist-cjs/commands/CreateBucketCommand.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateBucketCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates an Amazon Lightsail bucket.</p>
+ *
+ *          <p>A bucket is a cloud storage resource available in the Lightsail object storage service.
+ *       Use buckets to store objects such as data and its descriptive metadata. For more information
+ *       about buckets, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/buckets-in-amazon-lightsail">Buckets in Amazon Lightsail</a> in the <i>Amazon Lightsail Developer
+ *         Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, CreateBucketCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CreateBucketCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CreateBucketCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateBucketCommandInput} for command's `input` shape.
+ * @see {@link CreateBucketCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateBucketCommand 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 = "CreateBucketCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateBucketRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateBucketResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateBucketCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateBucketCommand(output, context);
+    }
+}
+exports.CreateBucketCommand = CreateBucketCommand;

package/dist-cjs/commands/CreateCertificateCommand.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCertificateCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates an SSL/TLS certificate for an Amazon Lightsail content delivery network (CDN)
+ *       distribution and a container service.</p>
+ *          <p>After the certificate is valid, use the <code>AttachCertificateToDistribution</code>
+ *       action to use the certificate and its domains with your distribution. Or use the
+ *         <code>UpdateContainerService</code> action to use the certificate and its domains with your
+ *       container service.</p>
+ *          <important>
+ *             <p>Only certificates created in the <code>us-east-1</code> AWS Region can be attached to
+ *         Lightsail distributions. Lightsail distributions are global resources that can reference
+ *         an origin in any AWS Region, and distribute its content globally. However, all
+ *         distributions are located in the <code>us-east-1</code> Region.</p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, CreateCertificateCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CreateCertificateCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CreateCertificateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateCertificateCommandInput} for command's `input` shape.
+ * @see {@link CreateCertificateCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateCertificateCommand 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 = "CreateCertificateCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateCertificateRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateCertificateResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateCertificateCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateCertificateCommand(output, context);
+    }
+}
+exports.CreateCertificateCommand = CreateCertificateCommand;

package/dist-cjs/commands/CreateCloudFormationStackCommand.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCloudFormationStackCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates an AWS CloudFormation stack, which creates a new Amazon EC2 instance from an exported
+ *       Amazon Lightsail snapshot. This operation results in a CloudFormation stack record that can be
+ *       used to track the AWS CloudFormation stack created. Use the <code>get cloud formation stack
+ *         records</code> operation to get a list of the CloudFormation stacks created.</p>
+ *          <important>
+ *             <p>Wait until after your new Amazon EC2 instance is created before running the <code>create
+ *           cloud formation stack</code> operation again with the same export snapshot record.</p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, CreateCloudFormationStackCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CreateCloudFormationStackCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CreateCloudFormationStackCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateCloudFormationStackCommandInput} for command's `input` shape.
+ * @see {@link CreateCloudFormationStackCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateCloudFormationStackCommand 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 = "CreateCloudFormationStackCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateCloudFormationStackRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateCloudFormationStackResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateCloudFormationStackCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateCloudFormationStackCommand(output, context);
+    }
+}
+exports.CreateCloudFormationStackCommand = CreateCloudFormationStackCommand;

package/dist-cjs/commands/CreateContactMethodCommand.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateContactMethodCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates an email or SMS text message contact method.</p>
+ *          <p>A contact method is used to send you notifications about your Amazon Lightsail resources.
+ *       You can add one email address and one mobile phone number contact method in each AWS Region.
+ *       However, SMS text messaging is not supported in some AWS Regions, and SMS text messages
+ *       cannot be sent to some countries/regions. For more information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-notifications">Notifications in Amazon Lightsail</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, CreateContactMethodCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CreateContactMethodCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CreateContactMethodCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateContactMethodCommandInput} for command's `input` shape.
+ * @see {@link CreateContactMethodCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateContactMethodCommand 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 = "CreateContactMethodCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateContactMethodRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateContactMethodResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateContactMethodCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateContactMethodCommand(output, context);
+    }
+}
+exports.CreateContactMethodCommand = CreateContactMethodCommand;

package/dist-cjs/commands/CreateContainerServiceCommand.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateContainerServiceCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates an Amazon Lightsail container service.</p>
+ *
+ *          <p>A Lightsail container service is a compute resource to which you can deploy containers.
+ *       For more information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-container-services">Container services in Amazon Lightsail</a> in the <i>Lightsail Dev
+ *         Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, CreateContainerServiceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CreateContainerServiceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CreateContainerServiceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateContainerServiceCommandInput} for command's `input` shape.
+ * @see {@link CreateContainerServiceCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateContainerServiceCommand 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 = "CreateContainerServiceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateContainerServiceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateContainerServiceResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateContainerServiceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateContainerServiceCommand(output, context);
+    }
+}
+exports.CreateContainerServiceCommand = CreateContainerServiceCommand;

package/dist-cjs/commands/CreateContainerServiceDeploymentCommand.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateContainerServiceDeploymentCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates a deployment for your Amazon Lightsail container service.</p>
+ *
+ *          <p>A deployment specifies the containers that will be launched on the container service and
+ *       their settings, such as the ports to open, the environment variables to apply, and the launch
+ *       command to run. It also specifies the container that will serve as the public endpoint of the
+ *       deployment and its settings, such as the HTTP or HTTPS port to use, and the health check
+ *       configuration.</p>
+ *
+ *          <p>You can deploy containers to your container service using container images from a public
+ *       registry like Docker Hub, or from your local machine. For more information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-creating-container-images">Creating container images for your Amazon Lightsail container services</a> in the
+ *         <i>Amazon Lightsail Developer Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, CreateContainerServiceDeploymentCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CreateContainerServiceDeploymentCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CreateContainerServiceDeploymentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateContainerServiceDeploymentCommandInput} for command's `input` shape.
+ * @see {@link CreateContainerServiceDeploymentCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateContainerServiceDeploymentCommand 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 = "CreateContainerServiceDeploymentCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateContainerServiceDeploymentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateContainerServiceDeploymentResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateContainerServiceDeploymentCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateContainerServiceDeploymentCommand(output, context);
+    }
+}
+exports.CreateContainerServiceDeploymentCommand = CreateContainerServiceDeploymentCommand;

package/dist-cjs/commands/CreateContainerServiceRegistryLoginCommand.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateContainerServiceRegistryLoginCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates a temporary set of log in credentials that you can use to log in to the Docker
+ *       process on your local machine. After you're logged in, you can use the native Docker commands
+ *       to push your local container images to the container image registry of your Amazon Lightsail
+ *       account so that you can use them with your Lightsail container service. The log in
+ *       credentials expire 12 hours after they are created, at which point you will need to create a
+ *       new set of log in credentials.</p>
+ *
+ *          <note>
+ *             <p>You can only push container images to the container service registry of your Lightsail
+ *         account. You cannot pull container images or perform any other container image management
+ *         actions on the container service registry.</p>
+ *          </note>
+ *
+ *          <p>After you push your container images to the container image registry of your Lightsail
+ *       account, use the <code>RegisterContainerImage</code> action to register the pushed images to a
+ *       specific Lightsail container service.</p>
+ *
+ *          <note>
+ *             <p>This action is not required if you install and use the Lightsail Control
+ *         (lightsailctl) plugin to push container images to your Lightsail container service. For
+ *         more information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-pushing-container-images">Pushing and managing container images on your Amazon Lightsail container services</a>
+ *         in the <i>Amazon Lightsail Developer Guide</i>.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, CreateContainerServiceRegistryLoginCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CreateContainerServiceRegistryLoginCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CreateContainerServiceRegistryLoginCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateContainerServiceRegistryLoginCommandInput} for command's `input` shape.
+ * @see {@link CreateContainerServiceRegistryLoginCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateContainerServiceRegistryLoginCommand 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 = "CreateContainerServiceRegistryLoginCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateContainerServiceRegistryLoginRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateContainerServiceRegistryLoginResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateContainerServiceRegistryLoginCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateContainerServiceRegistryLoginCommand(output, context);
+    }
+}
+exports.CreateContainerServiceRegistryLoginCommand = CreateContainerServiceRegistryLoginCommand;

package/dist-cjs/commands/CreateDiskCommand.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDiskCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates a block storage disk that can be attached to an Amazon Lightsail instance in the
+ *       same Availability Zone (e.g., <code>us-east-2a</code>).</p>
+ *          <p>The <code>create disk</code> operation supports tag-based access control via request tags.
+ *       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, CreateDiskCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CreateDiskCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CreateDiskCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDiskCommandInput} for command's `input` shape.
+ * @see {@link CreateDiskCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateDiskCommand 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 = "CreateDiskCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateDiskRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateDiskResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateDiskCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateDiskCommand(output, context);
+    }
+}
+exports.CreateDiskCommand = CreateDiskCommand;

package/dist-cjs/commands/CreateDiskFromSnapshotCommand.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDiskFromSnapshotCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates a block storage disk from a manual or automatic snapshot of a disk. The resulting
+ *       disk can be attached to an Amazon Lightsail instance in the same Availability Zone (e.g.,
+ *         <code>us-east-2a</code>).</p>
+ *          <p>The <code>create disk from snapshot</code> operation supports tag-based access control via
+ *       request tags and resource tags applied to the resource identified by <code>disk snapshot
+ *         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, CreateDiskFromSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CreateDiskFromSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CreateDiskFromSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDiskFromSnapshotCommandInput} for command's `input` shape.
+ * @see {@link CreateDiskFromSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateDiskFromSnapshotCommand 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 = "CreateDiskFromSnapshotCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateDiskFromSnapshotRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateDiskFromSnapshotResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateDiskFromSnapshotCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateDiskFromSnapshotCommand(output, context);
+    }
+}
+exports.CreateDiskFromSnapshotCommand = CreateDiskFromSnapshotCommand;