@aws-sdk/client-lightsail 3.35.0 → 3.38.0

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

@@ -6,36 +6,11 @@ export interface CreateCloudFormationStackCommandInput extends CreateCloudFormat
 }
 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

@@ -6,33 +6,11 @@ export interface CreateContactMethodCommandInput extends CreateContactMethodRequ
 }
 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

@@ -6,33 +6,11 @@ export interface CreateContainerServiceCommandInput extends CreateContainerServi
 }
 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

@@ -6,39 +6,11 @@ export interface CreateContainerServiceDeploymentCommandInput extends CreateCont
 }
 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

@@ -6,51 +6,11 @@ export interface CreateContainerServiceRegistryLoginCommandInput extends CreateC
 }
 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

@@ -6,32 +6,11 @@ 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

@@ -6,34 +6,11 @@ export interface CreateDiskFromSnapshotCommandInput extends CreateDiskFromSnapsh
 }
 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

@@ -6,48 +6,11 @@ export interface CreateDiskSnapshotCommandInput extends CreateDiskSnapshotReques
 }
 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

@@ -6,32 +6,11 @@ export interface CreateDistributionCommandInput extends CreateDistributionReques
 }
 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

@@ -6,31 +6,11 @@ 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;

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

@@ -6,37 +6,11 @@ export interface CreateDomainEntryCommandInput extends CreateDomainEntryRequest
 }
 export interface CreateDomainEntryCommandOutput extends CreateDomainEntryResult, __MetadataBearer {
 }
-/**
- * <p>Creates one of the following domain name system (DNS) records in a domain DNS zone:
- *       Address (A), canonical name (CNAME), mail exchanger (MX), name server (NS), start of authority
- *       (SOA), service locator (SRV), or text (TXT).</p>
- *
- *
- *
- *          <p>The <code>create domain entry</code> operation supports tag-based access control via
- *       resource tags applied to the resource identified by <code>domain 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, CreateDomainEntryCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateDomainEntryCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateDomainEntryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDomainEntryCommandInput} for command's `input` shape.
- * @see {@link CreateDomainEntryCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateDomainEntryCommand extends $Command<CreateDomainEntryCommandInput, CreateDomainEntryCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateDomainEntryCommandInput;
     constructor(input: CreateDomainEntryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDomainEntryCommandInput, CreateDomainEntryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface CreateInstanceSnapshotCommandInput extends CreateInstanceSnapsh
 }
 export interface CreateInstanceSnapshotCommandOutput extends CreateInstanceSnapshotResult, __MetadataBearer {
 }
-/**
- * <p>Creates a snapshot of a specific virtual private server, or <i>instance</i>.
- *       You can use a snapshot to create a new instance that is based on that snapshot.</p>
- *          <p>The <code>create instance 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, CreateInstanceSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateInstanceSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateInstanceSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateInstanceSnapshotCommandInput} for command's `input` shape.
- * @see {@link CreateInstanceSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateInstanceSnapshotCommand extends $Command<CreateInstanceSnapshotCommandInput, CreateInstanceSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateInstanceSnapshotCommandInput;
     constructor(input: CreateInstanceSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstanceSnapshotCommandInput, CreateInstanceSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateInstancesCommandInput extends CreateInstancesRequest {
 }
 export interface CreateInstancesCommandOutput extends CreateInstancesResult, __MetadataBearer {
 }
-/**
- * <p>Creates one or more Amazon Lightsail instances.</p>
- *          <p>The <code>create instances</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">Lightsail Developer Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, CreateInstancesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateInstancesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateInstancesCommandInput} for command's `input` shape.
- * @see {@link CreateInstancesCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateInstancesCommand extends $Command<CreateInstancesCommandInput, CreateInstancesCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateInstancesCommandInput;
     constructor(input: CreateInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstancesCommandInput, CreateInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface CreateInstancesFromSnapshotCommandInput extends CreateInstances
 }
 export interface CreateInstancesFromSnapshotCommandOutput extends CreateInstancesFromSnapshotResult, __MetadataBearer {
 }
-/**
- * <p>Creates one or more new instances from a manual or automatic snapshot of an
- *       instance.</p>
- *          <p>The <code>create instances from snapshot</code> operation supports tag-based access
- *       control via request tags and resource tags applied to the resource identified by
- *         <code>instance 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, CreateInstancesFromSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateInstancesFromSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateInstancesFromSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateInstancesFromSnapshotCommandInput} for command's `input` shape.
- * @see {@link CreateInstancesFromSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateInstancesFromSnapshotCommand extends $Command<CreateInstancesFromSnapshotCommandInput, CreateInstancesFromSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateInstancesFromSnapshotCommandInput;
     constructor(input: CreateInstancesFromSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstancesFromSnapshotCommandInput, CreateInstancesFromSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateKeyPairCommandInput extends CreateKeyPairRequest {
 }
 export interface CreateKeyPairCommandOutput extends CreateKeyPairResult, __MetadataBearer {
 }
-/**
- * <p>Creates an SSH key pair.</p>
- *          <p>The <code>create key pair</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, CreateKeyPairCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateKeyPairCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateKeyPairCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateKeyPairCommandInput} for command's `input` shape.
- * @see {@link CreateKeyPairCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateKeyPairCommand extends $Command<CreateKeyPairCommandInput, CreateKeyPairCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateKeyPairCommandInput;
     constructor(input: CreateKeyPairCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateKeyPairCommandInput, CreateKeyPairCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface CreateLoadBalancerCommandInput extends CreateLoadBalancerReques
 }
 export interface CreateLoadBalancerCommandOutput extends CreateLoadBalancerResult, __MetadataBearer {
 }
-/**
- * <p>Creates a Lightsail load balancer. To learn more about deciding whether to load balance
- *       your application, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/configure-lightsail-instances-for-load-balancing">Configure your Lightsail instances for load balancing</a>. You can create up to 5
- *       load balancers per AWS Region in your account.</p>
- *          <p>When you create a load balancer, you can specify a unique name and port settings. To
- *       change additional load balancer settings, use the <code>UpdateLoadBalancerAttribute</code>
- *       operation.</p>
- *          <p>The <code>create load balancer</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, CreateLoadBalancerCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateLoadBalancerCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateLoadBalancerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLoadBalancerCommandInput} for command's `input` shape.
- * @see {@link CreateLoadBalancerCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateLoadBalancerCommand extends $Command<CreateLoadBalancerCommandInput, CreateLoadBalancerCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateLoadBalancerCommandInput;
     constructor(input: CreateLoadBalancerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoadBalancerCommandInput, CreateLoadBalancerCommandOutput>;
     private serialize;
     private deserialize;