@aws-sdk/client-lightsail 3.296.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateInstanceSnapshotRequest, CreateInstanceSnapshotResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateInstanceSnapshotCommand}.
  */
 export interface CreateInstanceSnapshotCommandInput extends CreateInstanceSnapshotRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateInstanceSnapshotCommand}.
  */
 export interface CreateInstanceSnapshotCommandOutput extends CreateInstanceSnapshotResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -28,6 +33,8 @@ export interface CreateInstanceSnapshotCommandOutput extends CreateInstanceSnaps
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateInstanceSnapshotCommandInput - {@link CreateInstanceSnapshotCommandInput}
+ * @returns {@link CreateInstanceSnapshotCommandOutput}
  * @see {@link CreateInstanceSnapshotCommandInput} for command's `input` shape.
  * @see {@link CreateInstanceSnapshotCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -67,11 +74,20 @@ export interface CreateInstanceSnapshotCommandOutput extends CreateInstanceSnaps
 export declare class CreateInstanceSnapshotCommand extends $Command<CreateInstanceSnapshotCommandInput, CreateInstanceSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateInstanceSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateInstanceSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstanceSnapshotCommandInput, CreateInstanceSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateInstancesRequest, CreateInstancesResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateInstancesCommand}.
  */
 export interface CreateInstancesCommandInput extends CreateInstancesRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateInstancesCommand}.
  */
 export interface CreateInstancesCommandOutput extends CreateInstancesResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -27,6 +32,8 @@ export interface CreateInstancesCommandOutput extends CreateInstancesResult, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateInstancesCommandInput - {@link CreateInstancesCommandInput}
+ * @returns {@link CreateInstancesCommandOutput}
  * @see {@link CreateInstancesCommandInput} for command's `input` shape.
  * @see {@link CreateInstancesCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -66,11 +73,20 @@ export interface CreateInstancesCommandOutput extends CreateInstancesResult, __M
 export declare class CreateInstancesCommand extends $Command<CreateInstancesCommandInput, CreateInstancesCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateInstancesCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateInstancesCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstancesCommandInput, CreateInstancesCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateInstancesFromSnapshotRequest, CreateInstancesFromSnapshotResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateInstancesFromSnapshotCommand}.
  */
 export interface CreateInstancesFromSnapshotCommandInput extends CreateInstancesFromSnapshotRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateInstancesFromSnapshotCommand}.
  */
 export interface CreateInstancesFromSnapshotCommandOutput extends CreateInstancesFromSnapshotResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -29,6 +34,8 @@ export interface CreateInstancesFromSnapshotCommandOutput extends CreateInstance
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateInstancesFromSnapshotCommandInput - {@link CreateInstancesFromSnapshotCommandInput}
+ * @returns {@link CreateInstancesFromSnapshotCommandOutput}
  * @see {@link CreateInstancesFromSnapshotCommandInput} for command's `input` shape.
  * @see {@link CreateInstancesFromSnapshotCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -68,11 +75,20 @@ export interface CreateInstancesFromSnapshotCommandOutput extends CreateInstance
 export declare class CreateInstancesFromSnapshotCommand extends $Command<CreateInstancesFromSnapshotCommandInput, CreateInstancesFromSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateInstancesFromSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateInstancesFromSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstancesFromSnapshotCommandInput, CreateInstancesFromSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateKeyPairRequest, CreateKeyPairResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateKeyPairCommand}.
  */
 export interface CreateKeyPairCommandInput extends CreateKeyPairRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateKeyPairCommand}.
  */
 export interface CreateKeyPairCommandOutput extends CreateKeyPairResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a custom SSH key pair that you can use with an Amazon Lightsail
  *       instance.</p>
  *          <note>
@@ -33,6 +38,8 @@ export interface CreateKeyPairCommandOutput extends CreateKeyPairResult, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateKeyPairCommandInput - {@link CreateKeyPairCommandInput}
+ * @returns {@link CreateKeyPairCommandOutput}
  * @see {@link CreateKeyPairCommandInput} for command's `input` shape.
  * @see {@link CreateKeyPairCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -72,11 +79,20 @@ export interface CreateKeyPairCommandOutput extends CreateKeyPairResult, __Metad
 export declare class CreateKeyPairCommand extends $Command<CreateKeyPairCommandInput, CreateKeyPairCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateKeyPairCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateKeyPairCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateKeyPairCommandInput, CreateKeyPairCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateLoadBalancerRequest, CreateLoadBalancerResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateLoadBalancerCommand}.
  */
 export interface CreateLoadBalancerCommandInput extends CreateLoadBalancerRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateLoadBalancerCommand}.
  */
 export interface CreateLoadBalancerCommandOutput extends CreateLoadBalancerResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -32,6 +37,8 @@ export interface CreateLoadBalancerCommandOutput extends CreateLoadBalancerResul
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateLoadBalancerCommandInput - {@link CreateLoadBalancerCommandInput}
+ * @returns {@link CreateLoadBalancerCommandOutput}
  * @see {@link CreateLoadBalancerCommandInput} for command's `input` shape.
  * @see {@link CreateLoadBalancerCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -71,11 +78,20 @@ export interface CreateLoadBalancerCommandOutput extends CreateLoadBalancerResul
 export declare class CreateLoadBalancerCommand extends $Command<CreateLoadBalancerCommandInput, CreateLoadBalancerCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateLoadBalancerCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateLoadBalancerCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoadBalancerCommandInput, CreateLoadBalancerCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateLoadBalancerTlsCertificateRequest, CreateLoadBalancerTlsCertificateResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateLoadBalancerTlsCertificateCommand}.
  */
 export interface CreateLoadBalancerTlsCertificateCommandInput extends CreateLoadBalancerTlsCertificateRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateLoadBalancerTlsCertificateCommand}.
  */
 export interface CreateLoadBalancerTlsCertificateCommandOutput extends CreateLoadBalancerTlsCertificateResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -29,6 +34,8 @@ export interface CreateLoadBalancerTlsCertificateCommandOutput extends CreateLoa
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateLoadBalancerTlsCertificateCommandInput - {@link CreateLoadBalancerTlsCertificateCommandInput}
+ * @returns {@link CreateLoadBalancerTlsCertificateCommandOutput}
  * @see {@link CreateLoadBalancerTlsCertificateCommandInput} for command's `input` shape.
  * @see {@link CreateLoadBalancerTlsCertificateCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -68,11 +75,20 @@ export interface CreateLoadBalancerTlsCertificateCommandOutput extends CreateLoa
 export declare class CreateLoadBalancerTlsCertificateCommand extends $Command<CreateLoadBalancerTlsCertificateCommandInput, CreateLoadBalancerTlsCertificateCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateLoadBalancerTlsCertificateCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateLoadBalancerTlsCertificateCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoadBalancerTlsCertificateCommandInput, CreateLoadBalancerTlsCertificateCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateRelationalDatabaseRequest, CreateRelationalDatabaseResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateRelationalDatabaseCommand}.
  */
 export interface CreateRelationalDatabaseCommandInput extends CreateRelationalDatabaseRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateRelationalDatabaseCommand}.
  */
 export interface CreateRelationalDatabaseCommandOutput extends CreateRelationalDatabaseResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -27,6 +32,8 @@ export interface CreateRelationalDatabaseCommandOutput extends CreateRelationalD
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateRelationalDatabaseCommandInput - {@link CreateRelationalDatabaseCommandInput}
+ * @returns {@link CreateRelationalDatabaseCommandOutput}
  * @see {@link CreateRelationalDatabaseCommandInput} for command's `input` shape.
  * @see {@link CreateRelationalDatabaseCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -66,11 +73,20 @@ export interface CreateRelationalDatabaseCommandOutput extends CreateRelationalD
 export declare class CreateRelationalDatabaseCommand extends $Command<CreateRelationalDatabaseCommandInput, CreateRelationalDatabaseCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateRelationalDatabaseCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateRelationalDatabaseCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRelationalDatabaseCommandInput, CreateRelationalDatabaseCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateRelationalDatabaseFromSnapshotRequest, CreateRelationalDatabaseFromSnapshotResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateRelationalDatabaseFromSnapshotCommand}.
  */
 export interface CreateRelationalDatabaseFromSnapshotCommandInput extends CreateRelationalDatabaseFromSnapshotRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateRelationalDatabaseFromSnapshotCommand}.
  */
 export interface CreateRelationalDatabaseFromSnapshotCommandOutput extends CreateRelationalDatabaseFromSnapshotResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -31,6 +36,8 @@ export interface CreateRelationalDatabaseFromSnapshotCommandOutput extends Creat
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateRelationalDatabaseFromSnapshotCommandInput - {@link CreateRelationalDatabaseFromSnapshotCommandInput}
+ * @returns {@link CreateRelationalDatabaseFromSnapshotCommandOutput}
  * @see {@link CreateRelationalDatabaseFromSnapshotCommandInput} for command's `input` shape.
  * @see {@link CreateRelationalDatabaseFromSnapshotCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -70,11 +77,20 @@ export interface CreateRelationalDatabaseFromSnapshotCommandOutput extends Creat
 export declare class CreateRelationalDatabaseFromSnapshotCommand extends $Command<CreateRelationalDatabaseFromSnapshotCommandInput, CreateRelationalDatabaseFromSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateRelationalDatabaseFromSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateRelationalDatabaseFromSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRelationalDatabaseFromSnapshotCommandInput, CreateRelationalDatabaseFromSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { CreateRelationalDatabaseSnapshotRequest, CreateRelationalDatabaseSnapshotResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateRelationalDatabaseSnapshotCommand}.
  */
 export interface CreateRelationalDatabaseSnapshotCommandInput extends CreateRelationalDatabaseSnapshotRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateRelationalDatabaseSnapshotCommand}.
  */
 export interface CreateRelationalDatabaseSnapshotCommandOutput extends CreateRelationalDatabaseSnapshotResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -28,6 +33,8 @@ export interface CreateRelationalDatabaseSnapshotCommandOutput extends CreateRel
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateRelationalDatabaseSnapshotCommandInput - {@link CreateRelationalDatabaseSnapshotCommandInput}
+ * @returns {@link CreateRelationalDatabaseSnapshotCommandOutput}
  * @see {@link CreateRelationalDatabaseSnapshotCommandInput} for command's `input` shape.
  * @see {@link CreateRelationalDatabaseSnapshotCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -67,11 +74,20 @@ export interface CreateRelationalDatabaseSnapshotCommandOutput extends CreateRel
 export declare class CreateRelationalDatabaseSnapshotCommand extends $Command<CreateRelationalDatabaseSnapshotCommandInput, CreateRelationalDatabaseSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: CreateRelationalDatabaseSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateRelationalDatabaseSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRelationalDatabaseSnapshotCommandInput, CreateRelationalDatabaseSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { DeleteAlarmRequest, DeleteAlarmResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteAlarmCommand}.
  */
 export interface DeleteAlarmCommandInput extends DeleteAlarmRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteAlarmCommand}.
  */
 export interface DeleteAlarmCommandOutput extends DeleteAlarmResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -29,6 +34,8 @@ export interface DeleteAlarmCommandOutput extends DeleteAlarmResult, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteAlarmCommandInput - {@link DeleteAlarmCommandInput}
+ * @returns {@link DeleteAlarmCommandOutput}
  * @see {@link DeleteAlarmCommandInput} for command's `input` shape.
  * @see {@link DeleteAlarmCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -64,11 +71,20 @@ export interface DeleteAlarmCommandOutput extends DeleteAlarmResult, __MetadataB
 export declare class DeleteAlarmCommand extends $Command<DeleteAlarmCommandInput, DeleteAlarmCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteAlarmCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteAlarmCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAlarmCommandInput, DeleteAlarmCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { DeleteAutoSnapshotRequest, DeleteAutoSnapshotResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteAutoSnapshotCommand}.
  */
 export interface DeleteAutoSnapshotCommandInput extends DeleteAutoSnapshotRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteAutoSnapshotCommand}.
  */
 export interface DeleteAutoSnapshotCommandOutput extends DeleteAutoSnapshotResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface DeleteAutoSnapshotCommandOutput extends DeleteAutoSnapshotResul
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteAutoSnapshotCommandInput - {@link DeleteAutoSnapshotCommandInput}
+ * @returns {@link DeleteAutoSnapshotCommandOutput}
  * @see {@link DeleteAutoSnapshotCommandInput} for command's `input` shape.
  * @see {@link DeleteAutoSnapshotCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -60,11 +67,20 @@ export interface DeleteAutoSnapshotCommandOutput extends DeleteAutoSnapshotResul
 export declare class DeleteAutoSnapshotCommand extends $Command<DeleteAutoSnapshotCommandInput, DeleteAutoSnapshotCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteAutoSnapshotCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteAutoSnapshotCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAutoSnapshotCommandInput, DeleteAutoSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { DeleteBucketAccessKeyRequest, DeleteBucketAccessKeyResult } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteBucketAccessKeyCommand}.
  */
 export interface DeleteBucketAccessKeyCommandInput extends DeleteBucketAccessKeyRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteBucketAccessKeyCommand}.
  */
 export interface DeleteBucketAccessKeyCommandOutput extends DeleteBucketAccessKeyResult, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -28,6 +33,8 @@ export interface DeleteBucketAccessKeyCommandOutput extends DeleteBucketAccessKe
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteBucketAccessKeyCommandInput - {@link DeleteBucketAccessKeyCommandInput}
+ * @returns {@link DeleteBucketAccessKeyCommandOutput}
  * @see {@link DeleteBucketAccessKeyCommandInput} for command's `input` shape.
  * @see {@link DeleteBucketAccessKeyCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -60,11 +67,20 @@ export interface DeleteBucketAccessKeyCommandOutput extends DeleteBucketAccessKe
 export declare class DeleteBucketAccessKeyCommand extends $Command<DeleteBucketAccessKeyCommandInput, DeleteBucketAccessKeyCommandOutput, LightsailClientResolvedConfig> {
     readonly input: DeleteBucketAccessKeyCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteBucketAccessKeyCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBucketAccessKeyCommandInput, DeleteBucketAccessKeyCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }