@aws-sdk/client-lightsail 3.35.0 → 3.38.0

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

@@ -6,32 +6,11 @@ export interface GetRelationalDatabaseMetricDataCommandInput extends GetRelation
 }
 export interface GetRelationalDatabaseMetricDataCommandOutput extends GetRelationalDatabaseMetricDataResult, __MetadataBearer {
 }
-/**
- * <p>Returns the data points of the specified metric for a database in Amazon Lightsail.</p>
- *          <p>Metrics report the utilization of your resources, and the error counts generated by them.
- *       Monitor and collect metric data regularly to maintain the reliability, availability, and
- *       performance of your resources.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetRelationalDatabaseMetricDataCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetRelationalDatabaseMetricDataCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetRelationalDatabaseMetricDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRelationalDatabaseMetricDataCommandInput} for command's `input` shape.
- * @see {@link GetRelationalDatabaseMetricDataCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRelationalDatabaseMetricDataCommand extends $Command<GetRelationalDatabaseMetricDataCommandInput, GetRelationalDatabaseMetricDataCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetRelationalDatabaseMetricDataCommandInput;
     constructor(input: GetRelationalDatabaseMetricDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRelationalDatabaseMetricDataCommandInput, GetRelationalDatabaseMetricDataCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface GetRelationalDatabaseParametersCommandInput extends GetRelation
 }
 export interface GetRelationalDatabaseParametersCommandOutput extends GetRelationalDatabaseParametersResult, __MetadataBearer {
 }
-/**
- * <p>Returns all of the runtime parameters offered by the underlying database software, or
- *       engine, for a specific database in Amazon Lightsail.</p>
- *          <p>In addition to the parameter names and values, this operation returns other information
- *       about each parameter. This information includes whether changes require a reboot, whether the
- *       parameter is modifiable, the allowed values, and the data types.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetRelationalDatabaseParametersCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetRelationalDatabaseParametersCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetRelationalDatabaseParametersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRelationalDatabaseParametersCommandInput} for command's `input` shape.
- * @see {@link GetRelationalDatabaseParametersCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRelationalDatabaseParametersCommand extends $Command<GetRelationalDatabaseParametersCommandInput, GetRelationalDatabaseParametersCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetRelationalDatabaseParametersCommandInput;
     constructor(input: GetRelationalDatabaseParametersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRelationalDatabaseParametersCommandInput, GetRelationalDatabaseParametersCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,33 +6,11 @@ export interface OpenInstancePublicPortsCommandInput extends OpenInstancePublicP
 }
 export interface OpenInstancePublicPortsCommandOutput extends OpenInstancePublicPortsResult, __MetadataBearer {
 }
-/**
- * <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
- *       resource tags applied to the resource identified by <code>instanceName</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, OpenInstancePublicPortsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, OpenInstancePublicPortsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new OpenInstancePublicPortsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link OpenInstancePublicPortsCommandInput} for command's `input` shape.
- * @see {@link OpenInstancePublicPortsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class OpenInstancePublicPortsCommand extends $Command<OpenInstancePublicPortsCommandInput, OpenInstancePublicPortsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: OpenInstancePublicPortsCommandInput;
     constructor(input: OpenInstancePublicPortsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<OpenInstancePublicPortsCommandInput, OpenInstancePublicPortsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,39 +6,11 @@ export interface PutAlarmCommandInput extends PutAlarmRequest {
 }
 export interface PutAlarmCommandOutput extends PutAlarmResult, __MetadataBearer {
 }
-/**
- * <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
- *       on the Amazon Lightsail console. For more information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-alarms">Alarms
- *         in Amazon Lightsail</a>.</p>
- *          <p>When this action creates an alarm, the alarm state is immediately set to
- *         <code>INSUFFICIENT_DATA</code>. The alarm is then evaluated and its state is set
- *       appropriately. Any actions associated with the new state are then executed.</p>
- *          <p>When you update an existing alarm, its state is left unchanged, but the update completely
- *       overwrites the previous configuration of the alarm. The alarm is then evaluated with the
- *       updated configuration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, PutAlarmCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, PutAlarmCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new PutAlarmCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutAlarmCommandInput} for command's `input` shape.
- * @see {@link PutAlarmCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutAlarmCommand extends $Command<PutAlarmCommandInput, PutAlarmCommandOutput, LightsailClientResolvedConfig> {
     readonly input: PutAlarmCommandInput;
     constructor(input: PutAlarmCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAlarmCommandInput, PutAlarmCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface PutInstancePublicPortsCommandInput extends PutInstancePublicPor
 }
 export interface PutInstancePublicPortsCommandOutput extends PutInstancePublicPortsResult, __MetadataBearer {
 }
-/**
- * <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
- *       and the protocols you want to open in your <code>PutInstancePublicPorts</code>request. Or use
- *       the <code>OpenInstancePublicPorts</code> action to open ports without closing currently open
- *       ports.</p>
- *          <p>The <code>PutInstancePublicPorts</code> action supports tag-based access control via
- *       resource tags applied to the resource identified by <code>instanceName</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, PutInstancePublicPortsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, PutInstancePublicPortsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new PutInstancePublicPortsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutInstancePublicPortsCommandInput} for command's `input` shape.
- * @see {@link PutInstancePublicPortsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutInstancePublicPortsCommand extends $Command<PutInstancePublicPortsCommandInput, PutInstancePublicPortsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: PutInstancePublicPortsCommandInput;
     constructor(input: PutInstancePublicPortsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutInstancePublicPortsCommandInput, PutInstancePublicPortsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,36 +6,11 @@ export interface RegisterContainerImageCommandInput extends RegisterContainerIma
 }
 export interface RegisterContainerImageCommandOutput extends RegisterContainerImageResult, __MetadataBearer {
 }
-/**
- * <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
- *         (lightsailctl) plugin to push container images to your Lightsail container service. For
- *         more information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-pushing-container-images">Pushing and managing container images on your Amazon Lightsail container services</a>
- *         in the <i>Amazon Lightsail Developer Guide</i>.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, RegisterContainerImageCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, RegisterContainerImageCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new RegisterContainerImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RegisterContainerImageCommandInput} for command's `input` shape.
- * @see {@link RegisterContainerImageCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RegisterContainerImageCommand extends $Command<RegisterContainerImageCommandInput, RegisterContainerImageCommandOutput, LightsailClientResolvedConfig> {
     readonly input: RegisterContainerImageCommandInput;
     constructor(input: RegisterContainerImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterContainerImageCommandInput, RegisterContainerImageCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,32 +6,11 @@ export interface ResetDistributionCacheCommandInput extends ResetDistributionCac
 }
 export interface ResetDistributionCacheCommandOutput extends ResetDistributionCacheResult, __MetadataBearer {
 }
-/**
- * <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
- *       pulls, serves, and caches it from the origin.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, ResetDistributionCacheCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, ResetDistributionCacheCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new ResetDistributionCacheCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ResetDistributionCacheCommandInput} for command's `input` shape.
- * @see {@link ResetDistributionCacheCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ResetDistributionCacheCommand extends $Command<ResetDistributionCacheCommandInput, ResetDistributionCacheCommandOutput, LightsailClientResolvedConfig> {
     readonly input: ResetDistributionCacheCommandInput;
     constructor(input: ResetDistributionCacheCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetDistributionCacheCommandInput, ResetDistributionCacheCommandOutput>;
     private serialize;
     private deserialize;