@aws-sdk/client-lightsail 3.35.0 → 3.38.0

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

@@ -6,32 +6,11 @@ export interface DeleteInstanceCommandInput extends DeleteInstanceRequest {
 }
 export interface DeleteInstanceCommandOutput extends DeleteInstanceResult, __MetadataBearer {
 }
-/**
- * <p>Deletes an Amazon Lightsail instance.</p>
- *          <p>The <code>delete instance</code> operation supports tag-based access control via resource
- *       tags applied to the resource identified by <code>instance name</code>. For more information,
- *       see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteInstanceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteInstanceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteInstanceCommandInput} for command's `input` shape.
- * @see {@link DeleteInstanceCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteInstanceCommand extends $Command<DeleteInstanceCommandInput, DeleteInstanceCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteInstanceCommandInput;
     constructor(input: DeleteInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteInstanceCommandInput, DeleteInstanceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DeleteInstanceSnapshotCommandInput extends DeleteInstanceSnapsh
 }
 export interface DeleteInstanceSnapshotCommandOutput extends DeleteInstanceSnapshotResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a specific snapshot of a virtual private server (or
- *       <i>instance</i>).</p>
- *          <p>The <code>delete instance snapshot</code> operation supports tag-based access control via
- *       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, DeleteInstanceSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteInstanceSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteInstanceSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteInstanceSnapshotCommandInput} for command's `input` shape.
- * @see {@link DeleteInstanceSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteInstanceSnapshotCommand extends $Command<DeleteInstanceSnapshotCommandInput, DeleteInstanceSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteInstanceSnapshotCommandInput;
     constructor(input: DeleteInstanceSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteInstanceSnapshotCommandInput, DeleteInstanceSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteKeyPairCommandInput extends DeleteKeyPairRequest {
 }
 export interface DeleteKeyPairCommandOutput extends DeleteKeyPairResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a specific SSH key pair.</p>
- *          <p>The <code>delete key pair</code> operation supports tag-based access control via resource
- *       tags applied to the resource identified by <code>key pair 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, DeleteKeyPairCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteKeyPairCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteKeyPairCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteKeyPairCommandInput} for command's `input` shape.
- * @see {@link DeleteKeyPairCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteKeyPairCommand extends $Command<DeleteKeyPairCommandInput, DeleteKeyPairCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteKeyPairCommandInput;
     constructor(input: DeleteKeyPairCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteKeyPairCommandInput, DeleteKeyPairCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface DeleteKnownHostKeysCommandInput extends DeleteKnownHostKeysRequ
 }
 export interface DeleteKnownHostKeysCommandOutput extends DeleteKnownHostKeysResult, __MetadataBearer {
 }
-/**
- * <p>Deletes the known host key or certificate used by the Amazon Lightsail browser-based SSH or
- *       RDP clients to authenticate an instance. This operation enables the Lightsail browser-based
- *       SSH or RDP clients to connect to the instance after a host key mismatch.</p>
- *          <important>
- *             <p>Perform this operation only if you were expecting the host key or certificate mismatch
- *         or if you are familiar with the new host key or certificate on the instance. For more
- *         information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-troubleshooting-browser-based-ssh-rdp-client-connection">Troubleshooting connection issues when using the Amazon Lightsail browser-based SSH or RDP
- *           client</a>.</p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteKnownHostKeysCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteKnownHostKeysCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteKnownHostKeysCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteKnownHostKeysCommandInput} for command's `input` shape.
- * @see {@link DeleteKnownHostKeysCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteKnownHostKeysCommand extends $Command<DeleteKnownHostKeysCommandInput, DeleteKnownHostKeysCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteKnownHostKeysCommandInput;
     constructor(input: DeleteKnownHostKeysCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteKnownHostKeysCommandInput, DeleteKnownHostKeysCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DeleteLoadBalancerCommandInput extends DeleteLoadBalancerReques
 }
 export interface DeleteLoadBalancerCommandOutput extends DeleteLoadBalancerResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a Lightsail load balancer and all its associated SSL/TLS certificates. Once the
- *       load balancer is deleted, you will need to create a new load balancer, create a new
- *       certificate, and verify domain ownership again.</p>
- *          <p>The <code>delete load balancer</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, DeleteLoadBalancerCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteLoadBalancerCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteLoadBalancerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLoadBalancerCommandInput} for command's `input` shape.
- * @see {@link DeleteLoadBalancerCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteLoadBalancerCommand extends $Command<DeleteLoadBalancerCommandInput, DeleteLoadBalancerCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteLoadBalancerCommandInput;
     constructor(input: DeleteLoadBalancerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLoadBalancerCommandInput, DeleteLoadBalancerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteLoadBalancerTlsCertificateCommandInput extends DeleteLoad
 }
 export interface DeleteLoadBalancerTlsCertificateCommandOutput extends DeleteLoadBalancerTlsCertificateResult, __MetadataBearer {
 }
-/**
- * <p>Deletes an SSL/TLS certificate associated with a Lightsail load balancer.</p>
- *          <p>The <code>DeleteLoadBalancerTlsCertificate</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, DeleteLoadBalancerTlsCertificateCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteLoadBalancerTlsCertificateCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteLoadBalancerTlsCertificateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLoadBalancerTlsCertificateCommandInput} for command's `input` shape.
- * @see {@link DeleteLoadBalancerTlsCertificateCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteLoadBalancerTlsCertificateCommand extends $Command<DeleteLoadBalancerTlsCertificateCommandInput, DeleteLoadBalancerTlsCertificateCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteLoadBalancerTlsCertificateCommandInput;
     constructor(input: DeleteLoadBalancerTlsCertificateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLoadBalancerTlsCertificateCommandInput, DeleteLoadBalancerTlsCertificateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteRelationalDatabaseCommandInput extends DeleteRelationalDa
 }
 export interface DeleteRelationalDatabaseCommandOutput extends DeleteRelationalDatabaseResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a database in Amazon Lightsail.</p>
- *          <p>The <code>delete relational database</code> operation supports tag-based access control
- *       via resource tags applied to the resource identified by relationalDatabaseName. For more
- *       information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteRelationalDatabaseCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteRelationalDatabaseCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteRelationalDatabaseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteRelationalDatabaseCommandInput} for command's `input` shape.
- * @see {@link DeleteRelationalDatabaseCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteRelationalDatabaseCommand extends $Command<DeleteRelationalDatabaseCommandInput, DeleteRelationalDatabaseCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteRelationalDatabaseCommandInput;
     constructor(input: DeleteRelationalDatabaseCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRelationalDatabaseCommandInput, DeleteRelationalDatabaseCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteRelationalDatabaseSnapshotCommandInput extends DeleteRela
 }
 export interface DeleteRelationalDatabaseSnapshotCommandOutput extends DeleteRelationalDatabaseSnapshotResult, __MetadataBearer {
 }
-/**
- * <p>Deletes a database snapshot in Amazon Lightsail.</p>
- *          <p>The <code>delete relational database snapshot</code> operation supports tag-based access
- *       control via resource tags applied to the resource identified by relationalDatabaseName. For
- *       more information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteRelationalDatabaseSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteRelationalDatabaseSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteRelationalDatabaseSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteRelationalDatabaseSnapshotCommandInput} for command's `input` shape.
- * @see {@link DeleteRelationalDatabaseSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteRelationalDatabaseSnapshotCommand extends $Command<DeleteRelationalDatabaseSnapshotCommandInput, DeleteRelationalDatabaseSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteRelationalDatabaseSnapshotCommandInput;
     constructor(input: DeleteRelationalDatabaseSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRelationalDatabaseSnapshotCommandInput, DeleteRelationalDatabaseSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DetachCertificateFromDistributionCommandInput extends DetachCer
 }
 export interface DetachCertificateFromDistributionCommandOutput extends DetachCertificateFromDistributionResult, __MetadataBearer {
 }
-/**
- * <p>Detaches an SSL/TLS certificate from your Amazon Lightsail content delivery network (CDN)
- *       distribution.</p>
- *          <p>After the certificate is detached, your distribution stops accepting traffic for all of
- *       the domains that are associated with the certificate.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DetachCertificateFromDistributionCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DetachCertificateFromDistributionCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DetachCertificateFromDistributionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetachCertificateFromDistributionCommandInput} for command's `input` shape.
- * @see {@link DetachCertificateFromDistributionCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetachCertificateFromDistributionCommand extends $Command<DetachCertificateFromDistributionCommandInput, DetachCertificateFromDistributionCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DetachCertificateFromDistributionCommandInput;
     constructor(input: DetachCertificateFromDistributionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachCertificateFromDistributionCommandInput, DetachCertificateFromDistributionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DetachDiskCommandInput extends DetachDiskRequest {
 }
 export interface DetachDiskCommandOutput extends DetachDiskResult, __MetadataBearer {
 }
-/**
- * <p>Detaches a stopped block storage disk from a Lightsail instance. Make sure to unmount
- *       any file systems on the device within your operating system before stopping the instance and
- *       detaching the disk.</p>
- *          <p>The <code>detach 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, DetachDiskCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DetachDiskCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DetachDiskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetachDiskCommandInput} for command's `input` shape.
- * @see {@link DetachDiskCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetachDiskCommand extends $Command<DetachDiskCommandInput, DetachDiskCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DetachDiskCommandInput;
     constructor(input: DetachDiskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachDiskCommandInput, DetachDiskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DetachInstancesFromLoadBalancerCommandInput extends DetachInsta
 }
 export interface DetachInstancesFromLoadBalancerCommandOutput extends DetachInstancesFromLoadBalancerResult, __MetadataBearer {
 }
-/**
- * <p>Detaches the specified instances from a Lightsail load balancer.</p>
- *          <p>This operation waits until the instances are no longer needed before they are detached
- *       from the load balancer.</p>
- *          <p>The <code>detach instances from load balancer</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, DetachInstancesFromLoadBalancerCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DetachInstancesFromLoadBalancerCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DetachInstancesFromLoadBalancerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetachInstancesFromLoadBalancerCommandInput} for command's `input` shape.
- * @see {@link DetachInstancesFromLoadBalancerCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetachInstancesFromLoadBalancerCommand extends $Command<DetachInstancesFromLoadBalancerCommandInput, DetachInstancesFromLoadBalancerCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DetachInstancesFromLoadBalancerCommandInput;
     constructor(input: DetachInstancesFromLoadBalancerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachInstancesFromLoadBalancerCommandInput, DetachInstancesFromLoadBalancerCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface DisableAddOnCommandInput extends DisableAddOnRequest {
 }
 export interface DisableAddOnCommandOutput extends DisableAddOnResult, __MetadataBearer {
 }
-/**
- * <p>Disables an add-on for an Amazon Lightsail resource. 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, DisableAddOnCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DisableAddOnCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DisableAddOnCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableAddOnCommandInput} for command's `input` shape.
- * @see {@link DisableAddOnCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DisableAddOnCommand extends $Command<DisableAddOnCommandInput, DisableAddOnCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DisableAddOnCommandInput;
     constructor(input: DisableAddOnCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableAddOnCommandInput, DisableAddOnCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DownloadDefaultKeyPairCommandInput extends DownloadDefaultKeyPa
 }
 export interface DownloadDefaultKeyPairCommandOutput extends DownloadDefaultKeyPairResult, __MetadataBearer {
 }
-/**
- * <p>Downloads the default SSH key pair from the user's account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DownloadDefaultKeyPairCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DownloadDefaultKeyPairCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DownloadDefaultKeyPairCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DownloadDefaultKeyPairCommandInput} for command's `input` shape.
- * @see {@link DownloadDefaultKeyPairCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DownloadDefaultKeyPairCommand extends $Command<DownloadDefaultKeyPairCommandInput, DownloadDefaultKeyPairCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DownloadDefaultKeyPairCommandInput;
     constructor(input: DownloadDefaultKeyPairCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DownloadDefaultKeyPairCommandInput, DownloadDefaultKeyPairCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface EnableAddOnCommandInput extends EnableAddOnRequest {
 }
 export interface EnableAddOnCommandOutput extends EnableAddOnResult, __MetadataBearer {
 }
-/**
- * <p>Enables or modifies an add-on for an Amazon Lightsail resource. 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, EnableAddOnCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, EnableAddOnCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new EnableAddOnCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableAddOnCommandInput} for command's `input` shape.
- * @see {@link EnableAddOnCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableAddOnCommand extends $Command<EnableAddOnCommandInput, EnableAddOnCommandOutput, LightsailClientResolvedConfig> {
     readonly input: EnableAddOnCommandInput;
     constructor(input: EnableAddOnCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableAddOnCommandInput, EnableAddOnCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,43 +6,11 @@ export interface ExportSnapshotCommandInput extends ExportSnapshotRequest {
 }
 export interface ExportSnapshotCommandOutput extends ExportSnapshotResult, __MetadataBearer {
 }
-/**
- * <p>Exports an Amazon Lightsail instance or block storage disk snapshot to Amazon Elastic Compute Cloud (Amazon EC2).
- *       This operation results in an export snapshot record that can be used with the <code>create
- *         cloud formation stack</code> operation to create new Amazon EC2 instances.</p>
- *          <p>Exported instance snapshots appear in Amazon EC2 as Amazon Machine Images (AMIs), and the
- *       instance system disk appears as an Amazon Elastic Block Store (Amazon EBS) volume. Exported disk snapshots appear in
- *       Amazon EC2 as Amazon EBS volumes. Snapshots are exported to the same Amazon Web Services Region in Amazon EC2 as the
- *       source Lightsail snapshot.</p>
- *          <p></p>
- *          <p>The <code>export snapshot</code> operation supports tag-based access control via resource
- *       tags applied to the resource identified by <code>source 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>
- *          <note>
- *             <p>Use the <code>get instance snapshots</code> or <code>get disk snapshots</code>
- *         operations to get a list of snapshots that you can export to Amazon EC2.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, ExportSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, ExportSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new ExportSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ExportSnapshotCommandInput} for command's `input` shape.
- * @see {@link ExportSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ExportSnapshotCommand extends $Command<ExportSnapshotCommandInput, ExportSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: ExportSnapshotCommandInput;
     constructor(input: ExportSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExportSnapshotCommandInput, ExportSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetActiveNamesCommandInput extends GetActiveNamesRequest {
 }
 export interface GetActiveNamesCommandOutput extends GetActiveNamesResult, __MetadataBearer {
 }
-/**
- * <p>Returns the names of all active (not deleted) resources.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetActiveNamesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetActiveNamesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetActiveNamesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetActiveNamesCommandInput} for command's `input` shape.
- * @see {@link GetActiveNamesCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetActiveNamesCommand extends $Command<GetActiveNamesCommandInput, GetActiveNamesCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetActiveNamesCommandInput;
     constructor(input: GetActiveNamesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetActiveNamesCommandInput, GetActiveNamesCommandOutput>;
     private serialize;
     private deserialize;