@aws-sdk/client-lightsail 3.35.0 → 3.38.0

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

@@ -6,33 +6,11 @@ export interface CreateLoadBalancerTlsCertificateCommandInput extends CreateLoad
 }
 export interface CreateLoadBalancerTlsCertificateCommandOutput extends CreateLoadBalancerTlsCertificateResult, __MetadataBearer {
 }
-/**
- * <p>Creates an SSL/TLS certificate for an Amazon Lightsail load balancer.</p>
- *          <p>TLS is just an updated, more secure version of Secure Socket Layer (SSL).</p>
- *          <p>The <code>CreateLoadBalancerTlsCertificate</code> operation supports tag-based access
- *       control via resource tags applied to the resource identified by <code>load balancer
- *         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, CreateLoadBalancerTlsCertificateCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateLoadBalancerTlsCertificateCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateLoadBalancerTlsCertificateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLoadBalancerTlsCertificateCommandInput} for command's `input` shape.
- * @see {@link CreateLoadBalancerTlsCertificateCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateLoadBalancerTlsCertificateCommand extends $Command<CreateLoadBalancerTlsCertificateCommandInput, CreateLoadBalancerTlsCertificateCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateLoadBalancerTlsCertificateCommandInput;
     constructor(input: CreateLoadBalancerTlsCertificateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoadBalancerTlsCertificateCommandInput, CreateLoadBalancerTlsCertificateCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,35 +6,11 @@ export interface CreateRelationalDatabaseFromSnapshotCommandInput extends Create
 }
 export interface CreateRelationalDatabaseFromSnapshotCommandOutput extends CreateRelationalDatabaseFromSnapshotResult, __MetadataBearer {
 }
-/**
- * <p>Creates a new database from an existing database snapshot in Amazon Lightsail.</p>
- *          <p>You can create a new database from a snapshot in if something goes wrong with your
- *       original database, or to change it to a different plan, such as a high availability or
- *       standard plan.</p>
- *          <p>The <code>create relational database from snapshot</code> operation supports tag-based
- *       access control via request tags and resource tags applied to the resource identified by
- *       relationalDatabaseSnapshotName. 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, CreateRelationalDatabaseFromSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateRelationalDatabaseFromSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateRelationalDatabaseFromSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateRelationalDatabaseFromSnapshotCommandInput} for command's `input` shape.
- * @see {@link CreateRelationalDatabaseFromSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateRelationalDatabaseFromSnapshotCommand extends $Command<CreateRelationalDatabaseFromSnapshotCommandInput, CreateRelationalDatabaseFromSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateRelationalDatabaseFromSnapshotCommandInput;
     constructor(input: CreateRelationalDatabaseFromSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRelationalDatabaseFromSnapshotCommandInput, CreateRelationalDatabaseFromSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface CreateRelationalDatabaseSnapshotCommandInput extends CreateRela
 }
 export interface CreateRelationalDatabaseSnapshotCommandOutput extends CreateRelationalDatabaseSnapshotResult, __MetadataBearer {
 }
-/**
- * <p>Creates a snapshot of your database in Amazon Lightsail. You can use snapshots for backups,
- *       to make copies of a database, and to save data before deleting a database.</p>
- *          <p>The <code>create relational database 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, CreateRelationalDatabaseSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateRelationalDatabaseSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateRelationalDatabaseSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateRelationalDatabaseSnapshotCommandInput} for command's `input` shape.
- * @see {@link CreateRelationalDatabaseSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateRelationalDatabaseSnapshotCommand extends $Command<CreateRelationalDatabaseSnapshotCommandInput, CreateRelationalDatabaseSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateRelationalDatabaseSnapshotCommandInput;
     constructor(input: CreateRelationalDatabaseSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRelationalDatabaseSnapshotCommandInput, CreateRelationalDatabaseSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DeleteAlarmCommandInput extends DeleteAlarmRequest {
 }
 export interface DeleteAlarmCommandOutput extends DeleteAlarmResult, __MetadataBearer {
 }
-/**
- * <p>Deletes an alarm.</p>
- *          <p>An alarm is used to monitor a single metric for one of your resources. When a metric
- *       condition is met, the alarm can notify you by email, SMS text message, and a banner displayed
- *       on the Amazon Lightsail console. For more information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-alarms">Alarms
- *         in Amazon Lightsail</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteAlarmCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteAlarmCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteAlarmCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteAlarmCommandInput} for command's `input` shape.
- * @see {@link DeleteAlarmCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteAlarmCommand extends $Command<DeleteAlarmCommandInput, DeleteAlarmCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteAlarmCommandInput;
     constructor(input: DeleteAlarmCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAlarmCommandInput, DeleteAlarmCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteAutoSnapshotCommandInput extends DeleteAutoSnapshotReques
 }
 export interface DeleteAutoSnapshotCommandOutput extends DeleteAutoSnapshotResult, __MetadataBearer {
 }
-/**
- * <p>Deletes an automatic snapshot of an instance or disk. For more information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-configuring-automatic-snapshots">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, DeleteAutoSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteAutoSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteAutoSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteAutoSnapshotCommandInput} for command's `input` shape.
- * @see {@link DeleteAutoSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteAutoSnapshotCommand extends $Command<DeleteAutoSnapshotCommandInput, DeleteAutoSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteAutoSnapshotCommandInput;
     constructor(input: DeleteAutoSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAutoSnapshotCommandInput, DeleteAutoSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DeleteBucketAccessKeyCommandInput extends DeleteBucketAccessKey
 }
 export interface DeleteBucketAccessKeyCommandOutput extends DeleteBucketAccessKeyResult, __MetadataBearer {
 }
-/**
- * <p>Deletes an access key for the specified Amazon Lightsail bucket.</p>
- *
- *          <p>We recommend that you delete an access key if the secret access key is compromised.</p>
- *
- *          <p>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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteBucketAccessKeyCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteBucketAccessKeyCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteBucketAccessKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteBucketAccessKeyCommandInput} for command's `input` shape.
- * @see {@link DeleteBucketAccessKeyCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteBucketAccessKeyCommand extends $Command<DeleteBucketAccessKeyCommandInput, DeleteBucketAccessKeyCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteBucketAccessKeyCommandInput;
     constructor(input: DeleteBucketAccessKeyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBucketAccessKeyCommandInput, DeleteBucketAccessKeyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DeleteBucketCommandInput extends DeleteBucketRequest {
 }
 export interface DeleteBucketCommandOutput extends DeleteBucketResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a Amazon Lightsail bucket.</p>
- *
- *          <note>
- *             <p>When you delete your bucket, the bucket name is released and can be reused for a new
- *         bucket in your account or another AWS account.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteBucketCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteBucketCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteBucketCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteBucketCommandInput} for command's `input` shape.
- * @see {@link DeleteBucketCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteBucketCommand extends $Command<DeleteBucketCommandInput, DeleteBucketCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteBucketCommandInput;
     constructor(input: DeleteBucketCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBucketCommandInput, DeleteBucketCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DeleteCertificateCommandInput extends DeleteCertificateRequest
 }
 export interface DeleteCertificateCommandOutput extends DeleteCertificateResult, __MetadataBearer {
 }
-/**
- * <p>Deletes an SSL/TLS certificate for your Amazon Lightsail content delivery network (CDN)
- *       distribution.</p>
- *          <p>Certificates that are currently attached to a distribution cannot be deleted. Use the
- *         <code>DetachCertificateFromDistribution</code> action to detach a certificate from a
- *       distribution.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteCertificateCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteCertificateCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteCertificateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteCertificateCommandInput} for command's `input` shape.
- * @see {@link DeleteCertificateCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteCertificateCommand extends $Command<DeleteCertificateCommandInput, DeleteCertificateCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteCertificateCommandInput;
     constructor(input: DeleteCertificateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCertificateCommandInput, DeleteCertificateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DeleteContactMethodCommandInput extends DeleteContactMethodRequ
 }
 export interface DeleteContactMethodCommandOutput extends DeleteContactMethodResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a 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, DeleteContactMethodCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteContactMethodCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteContactMethodCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteContactMethodCommandInput} for command's `input` shape.
- * @see {@link DeleteContactMethodCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteContactMethodCommand extends $Command<DeleteContactMethodCommandInput, DeleteContactMethodCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteContactMethodCommandInput;
     constructor(input: DeleteContactMethodCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteContactMethodCommandInput, DeleteContactMethodCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteContainerImageCommandInput extends DeleteContainerImageRe
 }
 export interface DeleteContainerImageCommandOutput extends DeleteContainerImageResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a container image that is registered to your Amazon Lightsail container
- *       service.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteContainerImageCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteContainerImageCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteContainerImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteContainerImageCommandInput} for command's `input` shape.
- * @see {@link DeleteContainerImageCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteContainerImageCommand extends $Command<DeleteContainerImageCommandInput, DeleteContainerImageCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteContainerImageCommandInput;
     constructor(input: DeleteContainerImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteContainerImageCommandInput, DeleteContainerImageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteContainerServiceCommandInput extends DeleteContainerServi
 }
 export interface DeleteContainerServiceCommandOutput extends DeleteContainerServiceResult, __MetadataBearer {
 }
-/**
- * <p>Deletes your Amazon Lightsail container service.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteContainerServiceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteContainerServiceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteContainerServiceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteContainerServiceCommandInput} for command's `input` shape.
- * @see {@link DeleteContainerServiceCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteContainerServiceCommand extends $Command<DeleteContainerServiceCommandInput, DeleteContainerServiceCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteContainerServiceCommandInput;
     constructor(input: DeleteContainerServiceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteContainerServiceCommandInput, DeleteContainerServiceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface DeleteDiskCommandInput extends DeleteDiskRequest {
 }
 export interface DeleteDiskCommandOutput extends DeleteDiskResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified block storage disk. The disk must be in the <code>available</code>
- *       state (not attached to a Lightsail instance).</p>
- *          <note>
- *             <p>The disk may remain in the <code>deleting</code> state for several minutes.</p>
- *          </note>
- *          <p>The <code>delete disk</code> operation supports tag-based access control via resource tags
- *       applied to the resource identified by <code>disk 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, DeleteDiskCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteDiskCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteDiskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDiskCommandInput} for command's `input` shape.
- * @see {@link DeleteDiskCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDiskCommand extends $Command<DeleteDiskCommandInput, DeleteDiskCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteDiskCommandInput;
     constructor(input: DeleteDiskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDiskCommandInput, DeleteDiskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface DeleteDiskSnapshotCommandInput extends DeleteDiskSnapshotReques
 }
 export interface DeleteDiskSnapshotCommandOutput extends DeleteDiskSnapshotResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified disk snapshot.</p>
- *          <p>When you make periodic snapshots of a disk, the snapshots are incremental, and only the
- *       blocks on the device that have changed since your last snapshot are saved in the new snapshot.
- *       When you delete a snapshot, only the data not needed for any other snapshot is removed. So
- *       regardless of which prior snapshots have been deleted, all active snapshots will have access
- *       to all the information needed to restore the disk.</p>
- *          <p>The <code>delete disk snapshot</code> operation supports tag-based access control via
- *       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, DeleteDiskSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteDiskSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteDiskSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDiskSnapshotCommandInput} for command's `input` shape.
- * @see {@link DeleteDiskSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDiskSnapshotCommand extends $Command<DeleteDiskSnapshotCommandInput, DeleteDiskSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteDiskSnapshotCommandInput;
     constructor(input: DeleteDiskSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDiskSnapshotCommandInput, DeleteDiskSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteDistributionCommandInput extends DeleteDistributionReques
 }
 export interface DeleteDistributionCommandOutput extends DeleteDistributionResult, __MetadataBearer {
 }
-/**
- * <p>Deletes your Amazon Lightsail content delivery network (CDN) distribution.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteDistributionCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteDistributionCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteDistributionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDistributionCommandInput} for command's `input` shape.
- * @see {@link DeleteDistributionCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDistributionCommand extends $Command<DeleteDistributionCommandInput, DeleteDistributionCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteDistributionCommandInput;
     constructor(input: DeleteDistributionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDistributionCommandInput, DeleteDistributionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteDomainCommandInput extends DeleteDomainRequest {
 }
 export interface DeleteDomainCommandOutput extends DeleteDomainResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified domain recordset and all of its domain records.</p>
- *          <p>The <code>delete domain</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, DeleteDomainCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteDomainCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteDomainCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDomainCommandInput} for command's `input` shape.
- * @see {@link DeleteDomainCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDomainCommand extends $Command<DeleteDomainCommandInput, DeleteDomainCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteDomainCommandInput;
     constructor(input: DeleteDomainCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDomainCommandInput, DeleteDomainCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteDomainEntryCommandInput extends DeleteDomainEntryRequest
 }
 export interface DeleteDomainEntryCommandOutput extends DeleteDomainEntryResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a specific domain entry.</p>
- *          <p>The <code>delete 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, DeleteDomainEntryCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteDomainEntryCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteDomainEntryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDomainEntryCommandInput} for command's `input` shape.
- * @see {@link DeleteDomainEntryCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDomainEntryCommand extends $Command<DeleteDomainEntryCommandInput, DeleteDomainEntryCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteDomainEntryCommandInput;
     constructor(input: DeleteDomainEntryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDomainEntryCommandInput, DeleteDomainEntryCommandOutput>;
     private serialize;
     private deserialize;