@aws-sdk/client-lightsail 3.296.0 → 3.298.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { GetStaticIpsRequest, GetStaticIpsResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link GetStaticIpsCommand}.
  */
 export interface GetStaticIpsCommandInput extends GetStaticIpsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetStaticIpsCommand}.
  */
 export interface GetStaticIpsCommandOutput extends GetStaticIpsResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Returns information about all static IPs in the user's account.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface GetStaticIpsCommandOutput extends GetStaticIpsResult, __Metadat
  * const response = await client.send(command);
  * ```
  *
+ * @param GetStaticIpsCommandInput - {@link GetStaticIpsCommandInput}
+ * @returns {@link GetStaticIpsCommandOutput}
  * @see {@link GetStaticIpsCommandInput} for command's `input` shape.
  * @see {@link GetStaticIpsCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -64,11 +71,20 @@ export interface GetStaticIpsCommandOutput extends GetStaticIpsResult, __Metadat
 export declare class GetStaticIpsCommand extends $Command<GetStaticIpsCommandInput, GetStaticIpsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetStaticIpsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetStaticIpsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetStaticIpsCommandInput, GetStaticIpsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { ImportKeyPairRequest, ImportKeyPairResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link ImportKeyPairCommand}.
  */
 export interface ImportKeyPairCommandInput extends ImportKeyPairRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ImportKeyPairCommand}.
  */
 export interface ImportKeyPairCommandOutput extends ImportKeyPairResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Imports a public SSH key from a specific key pair.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface ImportKeyPairCommandOutput extends ImportKeyPairResult, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param ImportKeyPairCommandInput - {@link ImportKeyPairCommandInput}
+ * @returns {@link ImportKeyPairCommandOutput}
  * @see {@link ImportKeyPairCommandInput} for command's `input` shape.
  * @see {@link ImportKeyPairCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -64,11 +71,20 @@ export interface ImportKeyPairCommandOutput extends ImportKeyPairResult, __Metad
 export declare class ImportKeyPairCommand extends $Command<ImportKeyPairCommandInput, ImportKeyPairCommandOutput, LightsailClientResolvedConfig> {
     readonly input: ImportKeyPairCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ImportKeyPairCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportKeyPairCommandInput, ImportKeyPairCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { IsVpcPeeredRequest, IsVpcPeeredResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link IsVpcPeeredCommand}.
  */
 export interface IsVpcPeeredCommandInput extends IsVpcPeeredRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link IsVpcPeeredCommand}.
  */
 export interface IsVpcPeeredCommandOutput extends IsVpcPeeredResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Returns a Boolean value indicating whether your Lightsail VPC is peered.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface IsVpcPeeredCommandOutput extends IsVpcPeeredResult, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param IsVpcPeeredCommandInput - {@link IsVpcPeeredCommandInput}
+ * @returns {@link IsVpcPeeredCommandOutput}
  * @see {@link IsVpcPeeredCommandInput} for command's `input` shape.
  * @see {@link IsVpcPeeredCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -64,11 +71,20 @@ export interface IsVpcPeeredCommandOutput extends IsVpcPeeredResult, __MetadataB
 export declare class IsVpcPeeredCommand extends $Command<IsVpcPeeredCommandInput, IsVpcPeeredCommandOutput, LightsailClientResolvedConfig> {
     readonly input: IsVpcPeeredCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: IsVpcPeeredCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<IsVpcPeeredCommandInput, IsVpcPeeredCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { OpenInstancePublicPortsRequest, OpenInstancePublicPortsResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link OpenInstancePublicPortsCommand}.
  */
 export interface OpenInstancePublicPortsCommandInput extends OpenInstancePublicPortsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link OpenInstancePublicPortsCommand}.
  */
 export interface OpenInstancePublicPortsCommandOutput extends OpenInstancePublicPortsResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Opens ports for a specific Amazon Lightsail instance, and specifies the IP addresses
  *       allowed to connect to the instance through the ports, and the protocol.</p>
  *          <p>The <code>OpenInstancePublicPorts</code> action supports tag-based access control via
@@ -29,6 +34,8 @@ export interface OpenInstancePublicPortsCommandOutput extends OpenInstancePublic
  * const response = await client.send(command);
  * ```
  *
+ * @param OpenInstancePublicPortsCommandInput - {@link OpenInstancePublicPortsCommandInput}
+ * @returns {@link OpenInstancePublicPortsCommandOutput}
  * @see {@link OpenInstancePublicPortsCommandInput} for command's `input` shape.
  * @see {@link OpenInstancePublicPortsCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -68,11 +75,20 @@ export interface OpenInstancePublicPortsCommandOutput extends OpenInstancePublic
 export declare class OpenInstancePublicPortsCommand extends $Command<OpenInstancePublicPortsCommandInput, OpenInstancePublicPortsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: OpenInstancePublicPortsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: OpenInstancePublicPortsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<OpenInstancePublicPortsCommandInput, OpenInstancePublicPortsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { PeerVpcRequest, PeerVpcResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link PeerVpcCommand}.
  */
 export interface PeerVpcCommandInput extends PeerVpcRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link PeerVpcCommand}.
  */
 export interface PeerVpcCommandOutput extends PeerVpcResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Peers the Lightsail VPC with the user's default VPC.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface PeerVpcCommandOutput extends PeerVpcResult, __MetadataBearer {
  * const response = await client.send(command);
  * ```
  *
+ * @param PeerVpcCommandInput - {@link PeerVpcCommandInput}
+ * @returns {@link PeerVpcCommandOutput}
  * @see {@link PeerVpcCommandInput} for command's `input` shape.
  * @see {@link PeerVpcCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -64,11 +71,20 @@ export interface PeerVpcCommandOutput extends PeerVpcResult, __MetadataBearer {
 export declare class PeerVpcCommand extends $Command<PeerVpcCommandInput, PeerVpcCommandOutput, LightsailClientResolvedConfig> {
     readonly input: PeerVpcCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: PeerVpcCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PeerVpcCommandInput, PeerVpcCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { PutAlarmRequest, PutAlarmResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link PutAlarmCommand}.
  */
 export interface PutAlarmCommandInput extends PutAlarmRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link PutAlarmCommand}.
  */
 export interface PutAlarmCommandOutput extends PutAlarmResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates or updates an alarm, and associates it with the specified metric.</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
@@ -35,6 +40,8 @@ export interface PutAlarmCommandOutput extends PutAlarmResult, __MetadataBearer
  * const response = await client.send(command);
  * ```
  *
+ * @param PutAlarmCommandInput - {@link PutAlarmCommandInput}
+ * @returns {@link PutAlarmCommandOutput}
  * @see {@link PutAlarmCommandInput} for command's `input` shape.
  * @see {@link PutAlarmCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -70,11 +77,20 @@ export interface PutAlarmCommandOutput extends PutAlarmResult, __MetadataBearer
 export declare class PutAlarmCommand extends $Command<PutAlarmCommandInput, PutAlarmCommandOutput, LightsailClientResolvedConfig> {
     readonly input: PutAlarmCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: PutAlarmCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAlarmCommandInput, PutAlarmCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { PutInstancePublicPortsRequest, PutInstancePublicPortsResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link PutInstancePublicPortsCommand}.
  */
 export interface PutInstancePublicPortsCommandInput extends PutInstancePublicPortsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link PutInstancePublicPortsCommand}.
  */
 export interface PutInstancePublicPortsCommandOutput extends PutInstancePublicPortsResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Opens ports for a specific Amazon Lightsail instance, and specifies the IP addresses
  *       allowed to connect to the instance through the ports, and the protocol. This action also
  *       closes all currently open ports that are not included in the request. Include all of the ports
@@ -33,6 +38,8 @@ export interface PutInstancePublicPortsCommandOutput extends PutInstancePublicPo
  * const response = await client.send(command);
  * ```
  *
+ * @param PutInstancePublicPortsCommandInput - {@link PutInstancePublicPortsCommandInput}
+ * @returns {@link PutInstancePublicPortsCommandOutput}
  * @see {@link PutInstancePublicPortsCommandInput} for command's `input` shape.
  * @see {@link PutInstancePublicPortsCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -72,11 +79,20 @@ export interface PutInstancePublicPortsCommandOutput extends PutInstancePublicPo
 export declare class PutInstancePublicPortsCommand extends $Command<PutInstancePublicPortsCommandInput, PutInstancePublicPortsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: PutInstancePublicPortsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: PutInstancePublicPortsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutInstancePublicPortsCommandInput, PutInstancePublicPortsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { RebootInstanceRequest, RebootInstanceResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link RebootInstanceCommand}.
  */
 export interface RebootInstanceCommandInput extends RebootInstanceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link RebootInstanceCommand}.
  */
 export interface RebootInstanceCommandOutput extends RebootInstanceResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Restarts a specific instance.</p>
  *          <p>The <code>reboot instance</code> operation supports tag-based access control via resource
  *       tags applied to the resource identified by <code>instance name</code>. For more information,
@@ -28,6 +33,8 @@ export interface RebootInstanceCommandOutput extends RebootInstanceResult, __Met
  * const response = await client.send(command);
  * ```
  *
+ * @param RebootInstanceCommandInput - {@link RebootInstanceCommandInput}
+ * @returns {@link RebootInstanceCommandOutput}
  * @see {@link RebootInstanceCommandInput} for command's `input` shape.
  * @see {@link RebootInstanceCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -67,11 +74,20 @@ export interface RebootInstanceCommandOutput extends RebootInstanceResult, __Met
 export declare class RebootInstanceCommand extends $Command<RebootInstanceCommandInput, RebootInstanceCommandOutput, LightsailClientResolvedConfig> {
     readonly input: RebootInstanceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RebootInstanceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RebootInstanceCommandInput, RebootInstanceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { RebootRelationalDatabaseRequest, RebootRelationalDatabaseResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link RebootRelationalDatabaseCommand}.
  */
 export interface RebootRelationalDatabaseCommandInput extends RebootRelationalDatabaseRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link RebootRelationalDatabaseCommand}.
  */
 export interface RebootRelationalDatabaseCommandOutput extends RebootRelationalDatabaseResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Restarts a specific database in Amazon Lightsail.</p>
  *          <p>The <code>reboot relational database</code> operation supports tag-based access control
  *       via resource tags applied to the resource identified by relationalDatabaseName. For more
@@ -28,6 +33,8 @@ export interface RebootRelationalDatabaseCommandOutput extends RebootRelationalD
  * const response = await client.send(command);
  * ```
  *
+ * @param RebootRelationalDatabaseCommandInput - {@link RebootRelationalDatabaseCommandInput}
+ * @returns {@link RebootRelationalDatabaseCommandOutput}
  * @see {@link RebootRelationalDatabaseCommandInput} for command's `input` shape.
  * @see {@link RebootRelationalDatabaseCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -67,11 +74,20 @@ export interface RebootRelationalDatabaseCommandOutput extends RebootRelationalD
 export declare class RebootRelationalDatabaseCommand extends $Command<RebootRelationalDatabaseCommandInput, RebootRelationalDatabaseCommandOutput, LightsailClientResolvedConfig> {
     readonly input: RebootRelationalDatabaseCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RebootRelationalDatabaseCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RebootRelationalDatabaseCommandInput, RebootRelationalDatabaseCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { RegisterContainerImageRequest, RegisterContainerImageResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link RegisterContainerImageCommand}.
  */
 export interface RegisterContainerImageCommandInput extends RegisterContainerImageRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link RegisterContainerImageCommand}.
  */
 export interface RegisterContainerImageCommandOutput extends RegisterContainerImageResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Registers a container image to your Amazon Lightsail container service.</p>
  *          <note>
  *             <p>This action is not required if you install and use the Lightsail Control
@@ -31,6 +36,8 @@ export interface RegisterContainerImageCommandOutput extends RegisterContainerIm
  * const response = await client.send(command);
  * ```
  *
+ * @param RegisterContainerImageCommandInput - {@link RegisterContainerImageCommandInput}
+ * @returns {@link RegisterContainerImageCommandOutput}
  * @see {@link RegisterContainerImageCommandInput} for command's `input` shape.
  * @see {@link RegisterContainerImageCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -63,11 +70,20 @@ export interface RegisterContainerImageCommandOutput extends RegisterContainerIm
 export declare class RegisterContainerImageCommand extends $Command<RegisterContainerImageCommandInput, RegisterContainerImageCommandOutput, LightsailClientResolvedConfig> {
     readonly input: RegisterContainerImageCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: RegisterContainerImageCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterContainerImageCommandInput, RegisterContainerImageCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { ReleaseStaticIpRequest, ReleaseStaticIpResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link ReleaseStaticIpCommand}.
  */
 export interface ReleaseStaticIpCommandInput extends ReleaseStaticIpRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ReleaseStaticIpCommand}.
  */
 export interface ReleaseStaticIpCommandOutput extends ReleaseStaticIpResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a specific static IP from your account.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface ReleaseStaticIpCommandOutput extends ReleaseStaticIpResult, __M
  * const response = await client.send(command);
  * ```
  *
+ * @param ReleaseStaticIpCommandInput - {@link ReleaseStaticIpCommandInput}
+ * @returns {@link ReleaseStaticIpCommandOutput}
  * @see {@link ReleaseStaticIpCommandInput} for command's `input` shape.
  * @see {@link ReleaseStaticIpCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -64,11 +71,20 @@ export interface ReleaseStaticIpCommandOutput extends ReleaseStaticIpResult, __M
 export declare class ReleaseStaticIpCommand extends $Command<ReleaseStaticIpCommandInput, ReleaseStaticIpCommandOutput, LightsailClientResolvedConfig> {
     readonly input: ReleaseStaticIpCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ReleaseStaticIpCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReleaseStaticIpCommandInput, ReleaseStaticIpCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { ResetDistributionCacheRequest, ResetDistributionCacheResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link ResetDistributionCacheCommand}.
  */
 export interface ResetDistributionCacheCommandInput extends ResetDistributionCacheRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ResetDistributionCacheCommand}.
  */
 export interface ResetDistributionCacheCommandOutput extends ResetDistributionCacheResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes currently cached content from your Amazon Lightsail content delivery network (CDN)
  *       distribution.</p>
  *          <p>After resetting the cache, the next time a content request is made, your distribution
@@ -28,6 +33,8 @@ export interface ResetDistributionCacheCommandOutput extends ResetDistributionCa
  * const response = await client.send(command);
  * ```
  *
+ * @param ResetDistributionCacheCommandInput - {@link ResetDistributionCacheCommandInput}
+ * @returns {@link ResetDistributionCacheCommandOutput}
  * @see {@link ResetDistributionCacheCommandInput} for command's `input` shape.
  * @see {@link ResetDistributionCacheCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -63,11 +70,20 @@ export interface ResetDistributionCacheCommandOutput extends ResetDistributionCa
 export declare class ResetDistributionCacheCommand extends $Command<ResetDistributionCacheCommandInput, ResetDistributionCacheCommandOutput, LightsailClientResolvedConfig> {
     readonly input: ResetDistributionCacheCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ResetDistributionCacheCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetDistributionCacheCommandInput, ResetDistributionCacheCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
 import { SendContactMethodVerificationRequest, SendContactMethodVerificationResult } from "../models/models_1";
 /**
+ * @public
+ *
  * The input for {@link SendContactMethodVerificationCommand}.
  */
 export interface SendContactMethodVerificationCommandInput extends SendContactMethodVerificationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link SendContactMethodVerificationCommand}.
  */
 export interface SendContactMethodVerificationCommandOutput extends SendContactMethodVerificationResult, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Sends a verification request to an email contact method to ensure it's owned by the
  *       requester. SMS contact methods don't need to be verified.</p>
  *          <p>A contact method is used to send you notifications about your Amazon Lightsail resources.
@@ -37,6 +42,8 @@ export interface SendContactMethodVerificationCommandOutput extends SendContactM
  * const response = await client.send(command);
  * ```
  *
+ * @param SendContactMethodVerificationCommandInput - {@link SendContactMethodVerificationCommandInput}
+ * @returns {@link SendContactMethodVerificationCommandOutput}
  * @see {@link SendContactMethodVerificationCommandInput} for command's `input` shape.
  * @see {@link SendContactMethodVerificationCommandOutput} for command's `response` shape.
  * @see {@link LightsailClientResolvedConfig | config} for LightsailClient's `config` shape.
@@ -72,11 +79,20 @@ export interface SendContactMethodVerificationCommandOutput extends SendContactM
 export declare class SendContactMethodVerificationCommand extends $Command<SendContactMethodVerificationCommandInput, SendContactMethodVerificationCommandOutput, LightsailClientResolvedConfig> {
     readonly input: SendContactMethodVerificationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: SendContactMethodVerificationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendContactMethodVerificationCommandInput, SendContactMethodVerificationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }