@aws-sdk/client-lightsail 3.32.0 → 3.36.0

package/dist-types/ts3.4/commands/CopySnapshotCommand.d.ts

@@ -0,0 +1,45 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CopySnapshotRequest, CopySnapshotResult } from "../models/models_0";
+export interface CopySnapshotCommandInput extends CopySnapshotRequest {
+}
+export interface CopySnapshotCommandOutput extends CopySnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>Copies a manual snapshot of an instance or disk as another manual snapshot, or copies an
+ *       automatic snapshot of an instance or disk as a manual snapshot. This operation can also be
+ *       used to copy a manual or automatic snapshot of an instance or a disk from one AWS Region to
+ *       another in Amazon Lightsail.</p>
+ *          <p>When copying a <i>manual snapshot</i>, be sure to define the <code>source
+ *         region</code>, <code>source snapshot name</code>, and <code>target snapshot name</code>
+ *       parameters.</p>
+ *          <p>When copying an <i>automatic snapshot</i>, be sure to define the
+ *         <code>source region</code>, <code>source resource name</code>, <code>target snapshot
+ *         name</code>, and either the <code>restore date</code> or the <code>use latest restorable
+ *         auto snapshot</code> parameters.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, CopySnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CopySnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CopySnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CopySnapshotCommandInput} for command's `input` shape.
+ * @see {@link CopySnapshotCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CopySnapshotCommand extends $Command<CopySnapshotCommandInput, CopySnapshotCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CopySnapshotCommandInput;
+    constructor(input: CopySnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CopySnapshotCommandInput, CopySnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateBucketAccessKeyCommand.d.ts

@@ -0,0 +1,48 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CreateBucketAccessKeyRequest, CreateBucketAccessKeyResult } from "../models/models_0";
+export interface CreateBucketAccessKeyCommandInput extends CreateBucketAccessKeyRequest {
+}
+export interface CreateBucketAccessKeyCommandOutput extends CreateBucketAccessKeyResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a new access key for the specified Amazon Lightsail bucket. Access keys consist of
+ *       an access key ID and corresponding secret access key.</p>
+ *
+ *          <p>Access keys grant full programmatic access to the specified bucket and its objects. You
+ *       can have a maximum of two access keys per bucket. Use the <a>GetBucketAccessKeys</a> action to get a list of current access keys for a specific bucket. For more information
+ *       about access keys, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-creating-bucket-access-keys">Creating access keys for a bucket in Amazon Lightsail</a> in the
+ *         <i>Amazon Lightsail Developer Guide</i>.</p>
+ *
+ *          <important>
+ *             <p>The <code>secretAccessKey</code> value is returned only in response to the
+ *           <code>CreateBucketAccessKey</code> action. You can get a secret access key only when you
+ *         first create an access key; you cannot get the secret access key later. If you lose the
+ *         secret access key, you must create a new access key.</p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, CreateBucketAccessKeyCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CreateBucketAccessKeyCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CreateBucketAccessKeyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateBucketAccessKeyCommandInput} for command's `input` shape.
+ * @see {@link CreateBucketAccessKeyCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateBucketAccessKeyCommand extends $Command<CreateBucketAccessKeyCommandInput, CreateBucketAccessKeyCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CreateBucketAccessKeyCommandInput;
+    constructor(input: CreateBucketAccessKeyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateBucketAccessKeyCommandInput, CreateBucketAccessKeyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateBucketCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CreateBucketRequest, CreateBucketResult } from "../models/models_0";
+export interface CreateBucketCommandInput extends CreateBucketRequest {
+}
+export interface CreateBucketCommandOutput extends CreateBucketResult, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class CreateBucketCommand extends $Command<CreateBucketCommandInput, CreateBucketCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CreateBucketCommandInput;
+    constructor(input: CreateBucketCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateBucketCommandInput, CreateBucketCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateCertificateCommand.d.ts

@@ -0,0 +1,46 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CreateCertificateRequest, CreateCertificateResult } from "../models/models_0";
+export interface CreateCertificateCommandInput extends CreateCertificateRequest {
+}
+export interface CreateCertificateCommandOutput extends CreateCertificateResult, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class CreateCertificateCommand extends $Command<CreateCertificateCommandInput, CreateCertificateCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CreateCertificateCommandInput;
+    constructor(input: CreateCertificateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCertificateCommandInput, CreateCertificateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateCloudFormationStackCommand.d.ts

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CreateCloudFormationStackRequest, CreateCloudFormationStackResult } from "../models/models_0";
+export interface CreateCloudFormationStackCommandInput extends CreateCloudFormationStackRequest {
+}
+export interface CreateCloudFormationStackCommandOutput extends CreateCloudFormationStackResult, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class CreateCloudFormationStackCommand extends $Command<CreateCloudFormationStackCommandInput, CreateCloudFormationStackCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CreateCloudFormationStackCommandInput;
+    constructor(input: CreateCloudFormationStackCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCloudFormationStackCommandInput, CreateCloudFormationStackCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateContactMethodCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CreateContactMethodRequest, CreateContactMethodResult } from "../models/models_0";
+export interface CreateContactMethodCommandInput extends CreateContactMethodRequest {
+}
+export interface CreateContactMethodCommandOutput extends CreateContactMethodResult, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class CreateContactMethodCommand extends $Command<CreateContactMethodCommandInput, CreateContactMethodCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CreateContactMethodCommandInput;
+    constructor(input: CreateContactMethodCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateContactMethodCommandInput, CreateContactMethodCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateContainerServiceCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CreateContainerServiceRequest, CreateContainerServiceResult } from "../models/models_0";
+export interface CreateContainerServiceCommandInput extends CreateContainerServiceRequest {
+}
+export interface CreateContainerServiceCommandOutput extends CreateContainerServiceResult, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class CreateContainerServiceCommand extends $Command<CreateContainerServiceCommandInput, CreateContainerServiceCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CreateContainerServiceCommandInput;
+    constructor(input: CreateContainerServiceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateContainerServiceCommandInput, CreateContainerServiceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateContainerServiceDeploymentCommand.d.ts

@@ -0,0 +1,45 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CreateContainerServiceDeploymentRequest, CreateContainerServiceDeploymentResult } from "../models/models_0";
+export interface CreateContainerServiceDeploymentCommandInput extends CreateContainerServiceDeploymentRequest {
+}
+export interface CreateContainerServiceDeploymentCommandOutput extends CreateContainerServiceDeploymentResult, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class CreateContainerServiceDeploymentCommand extends $Command<CreateContainerServiceDeploymentCommandInput, CreateContainerServiceDeploymentCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CreateContainerServiceDeploymentCommandInput;
+    constructor(input: CreateContainerServiceDeploymentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateContainerServiceDeploymentCommandInput, CreateContainerServiceDeploymentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateContainerServiceRegistryLoginCommand.d.ts

@@ -0,0 +1,57 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CreateContainerServiceRegistryLoginRequest, CreateContainerServiceRegistryLoginResult } from "../models/models_0";
+export interface CreateContainerServiceRegistryLoginCommandInput extends CreateContainerServiceRegistryLoginRequest {
+}
+export interface CreateContainerServiceRegistryLoginCommandOutput extends CreateContainerServiceRegistryLoginResult, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class CreateContainerServiceRegistryLoginCommand extends $Command<CreateContainerServiceRegistryLoginCommandInput, CreateContainerServiceRegistryLoginCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CreateContainerServiceRegistryLoginCommandInput;
+    constructor(input: CreateContainerServiceRegistryLoginCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateContainerServiceRegistryLoginCommandInput, CreateContainerServiceRegistryLoginCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateDiskCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CreateDiskRequest, CreateDiskResult } from "../models/models_0";
+export interface CreateDiskCommandInput extends CreateDiskRequest {
+}
+export interface CreateDiskCommandOutput extends CreateDiskResult, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class CreateDiskCommand extends $Command<CreateDiskCommandInput, CreateDiskCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CreateDiskCommandInput;
+    constructor(input: CreateDiskCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDiskCommandInput, CreateDiskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateDiskFromSnapshotCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CreateDiskFromSnapshotRequest, CreateDiskFromSnapshotResult } from "../models/models_0";
+export interface CreateDiskFromSnapshotCommandInput extends CreateDiskFromSnapshotRequest {
+}
+export interface CreateDiskFromSnapshotCommandOutput extends CreateDiskFromSnapshotResult, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class CreateDiskFromSnapshotCommand extends $Command<CreateDiskFromSnapshotCommandInput, CreateDiskFromSnapshotCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CreateDiskFromSnapshotCommandInput;
+    constructor(input: CreateDiskFromSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDiskFromSnapshotCommandInput, CreateDiskFromSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateDiskSnapshotCommand.d.ts

@@ -0,0 +1,54 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CreateDiskSnapshotRequest, CreateDiskSnapshotResult } from "../models/models_0";
+export interface CreateDiskSnapshotCommandInput extends CreateDiskSnapshotRequest {
+}
+export interface CreateDiskSnapshotCommandOutput extends CreateDiskSnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a snapshot of a block storage disk. You can use snapshots for backups, to make
+ *       copies of disks, and to save data before shutting down a Lightsail instance.</p>
+ *          <p>You can take a snapshot of an attached disk that is in use; however, snapshots only
+ *       capture data that has been written to your disk at the time the snapshot command is issued.
+ *       This may exclude any data that has been cached by any applications or the operating system. If
+ *       you can pause any file systems on the disk long enough to take a snapshot, your snapshot
+ *       should be complete. Nevertheless, if you cannot pause all file writes to the disk, you should
+ *       unmount the disk from within the Lightsail instance, issue the create disk snapshot command,
+ *       and then remount the disk to ensure a consistent and complete snapshot. You may remount and
+ *       use your disk while the snapshot status is pending.</p>
+ *          <p>You can also use this operation to create a snapshot of an instance's system volume. You
+ *       might want to do this, for example, to recover data from the system volume of a botched
+ *       instance or to create a backup of the system volume like you would for a block storage disk.
+ *       To create a snapshot of a system volume, just define the <code>instance name</code> parameter
+ *       when issuing the snapshot command, and a snapshot of the defined instance's system volume will
+ *       be created. After the snapshot is available, you can create a block storage disk from the
+ *       snapshot and attach it to a running instance to access the data on the disk.</p>
+ *
+ *          <p>The <code>create disk snapshot</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, CreateDiskSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CreateDiskSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CreateDiskSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDiskSnapshotCommandInput} for command's `input` shape.
+ * @see {@link CreateDiskSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateDiskSnapshotCommand extends $Command<CreateDiskSnapshotCommandInput, CreateDiskSnapshotCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CreateDiskSnapshotCommandInput;
+    constructor(input: CreateDiskSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDiskSnapshotCommandInput, CreateDiskSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateDistributionCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CreateDistributionRequest, CreateDistributionResult } from "../models/models_0";
+export interface CreateDistributionCommandInput extends CreateDistributionRequest {
+}
+export interface CreateDistributionCommandOutput extends CreateDistributionResult, __MetadataBearer {
+}
+/**
+ * <p>Creates an Amazon Lightsail content delivery network (CDN) distribution.</p>
+ *          <p>A distribution is a globally distributed network of caching servers that improve the
+ *       performance of your website or web application hosted on a Lightsail instance. For more
+ *       information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-content-delivery-network-distributions">Content delivery networks in Amazon Lightsail</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, CreateDistributionCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CreateDistributionCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CreateDistributionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDistributionCommandInput} for command's `input` shape.
+ * @see {@link CreateDistributionCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateDistributionCommand extends $Command<CreateDistributionCommandInput, CreateDistributionCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CreateDistributionCommandInput;
+    constructor(input: CreateDistributionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDistributionCommandInput, CreateDistributionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/CreateDomainCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { CreateDomainRequest, CreateDomainResult } from "../models/models_0";
+export interface CreateDomainCommandInput extends CreateDomainRequest {
+}
+export interface CreateDomainCommandOutput extends CreateDomainResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a domain resource for the specified domain (e.g., example.com).</p>
+ *          <p>The <code>create domain</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, CreateDomainCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, CreateDomainCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new CreateDomainCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDomainCommandInput} for command's `input` shape.
+ * @see {@link CreateDomainCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateDomainCommand extends $Command<CreateDomainCommandInput, CreateDomainCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: CreateDomainCommandInput;
+    constructor(input: CreateDomainCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDomainCommandInput, CreateDomainCommandOutput>;
+    private serialize;
+    private deserialize;
+}