@aws-sdk/client-lightsail 3.35.0 → 3.38.0

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

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

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

@@ -6,30 +6,11 @@ export interface GetAutoSnapshotsCommandInput extends GetAutoSnapshotsRequest {
 }
 export interface GetAutoSnapshotsCommandOutput extends GetAutoSnapshotsResult, __MetadataBearer {
 }
-/**
- * <p>Returns the available automatic snapshots for an instance or disk. For more information,
- *       see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-configuring-automatic-snapshots">Amazon Lightsail Developer Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetAutoSnapshotsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetAutoSnapshotsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetAutoSnapshotsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAutoSnapshotsCommandInput} for command's `input` shape.
- * @see {@link GetAutoSnapshotsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAutoSnapshotsCommand extends $Command<GetAutoSnapshotsCommandInput, GetAutoSnapshotsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetAutoSnapshotsCommandInput;
     constructor(input: GetAutoSnapshotsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAutoSnapshotsCommandInput, GetAutoSnapshotsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface GetBlueprintsCommandInput extends GetBlueprintsRequest {
 }
 export interface GetBlueprintsCommandOutput extends GetBlueprintsResult, __MetadataBearer {
 }
-/**
- * <p>Returns the list of available instance images, or <i>blueprints</i>. You can
- *       use a blueprint to create a new instance already running a specific operating system, as well
- *       as a preinstalled app or development stack. The software each instance is running depends on
- *       the blueprint image you choose.</p>
- *          <note>
- *             <p>Use active blueprints when creating new instances. Inactive blueprints are listed to
- *         support customers with existing instances and are not necessarily available to create new
- *         instances. Blueprints are marked inactive when they become outdated due to operating system
- *         updates or new application releases.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetBlueprintsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetBlueprintsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetBlueprintsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetBlueprintsCommandInput} for command's `input` shape.
- * @see {@link GetBlueprintsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetBlueprintsCommand extends $Command<GetBlueprintsCommandInput, GetBlueprintsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetBlueprintsCommandInput;
     constructor(input: GetBlueprintsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBlueprintsCommandInput, GetBlueprintsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface GetBucketAccessKeysCommandInput extends GetBucketAccessKeysRequ
 }
 export interface GetBucketAccessKeysCommandOutput extends GetBucketAccessKeysResult, __MetadataBearer {
 }
-/**
- * <p>Returns the existing access key IDs for the specified Amazon Lightsail bucket.</p>
- *
- *          <important>
- *             <p>This action does not return the secret access key value of an access key. You can get a
- *         secret access key only when you create it from the response of the <a>CreateBucketAccessKey</a> action. If you lose the secret access key, you must
- *         create a new access key.</p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetBucketAccessKeysCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetBucketAccessKeysCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetBucketAccessKeysCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetBucketAccessKeysCommandInput} for command's `input` shape.
- * @see {@link GetBucketAccessKeysCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetBucketAccessKeysCommand extends $Command<GetBucketAccessKeysCommandInput, GetBucketAccessKeysCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetBucketAccessKeysCommandInput;
     constructor(input: GetBucketAccessKeysCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBucketAccessKeysCommandInput, GetBucketAccessKeysCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface GetBucketBundlesCommandInput extends GetBucketBundlesRequest {
 }
 export interface GetBucketBundlesCommandOutput extends GetBucketBundlesResult, __MetadataBearer {
 }
-/**
- * <p>Returns the bundles that you can apply to a Amazon Lightsail bucket.</p>
- *
- *          <p>The bucket bundle specifies the monthly cost, storage quota, and data transfer quota for a
- *       bucket.</p>
- *
- *          <p>Use the <a>UpdateBucketBundle</a> action to update the bundle for a
- *       bucket.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetBucketBundlesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetBucketBundlesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetBucketBundlesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetBucketBundlesCommandInput} for command's `input` shape.
- * @see {@link GetBucketBundlesCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetBucketBundlesCommand extends $Command<GetBucketBundlesCommandInput, GetBucketBundlesCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetBucketBundlesCommandInput;
     constructor(input: GetBucketBundlesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBucketBundlesCommandInput, GetBucketBundlesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface GetBucketMetricDataCommandInput extends GetBucketMetricDataRequ
 }
 export interface GetBucketMetricDataCommandOutput extends GetBucketMetricDataResult, __MetadataBearer {
 }
-/**
- * <p>Returns the data points of a specific metric for an Amazon Lightsail bucket.</p>
- *
- *          <p>Metrics report the utilization of a bucket. View and collect metric data regularly to
- *       monitor the number of objects stored in a bucket (including object versions) and the storage
- *       space used by those objects.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetBucketMetricDataCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetBucketMetricDataCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetBucketMetricDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetBucketMetricDataCommandInput} for command's `input` shape.
- * @see {@link GetBucketMetricDataCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetBucketMetricDataCommand extends $Command<GetBucketMetricDataCommandInput, GetBucketMetricDataCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetBucketMetricDataCommandInput;
     constructor(input: GetBucketMetricDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBucketMetricDataCommandInput, GetBucketMetricDataCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetBucketsCommandInput extends GetBucketsRequest {
 }
 export interface GetBucketsCommandOutput extends GetBucketsResult, __MetadataBearer {
 }
-/**
- * <p>Returns information about one or more Amazon Lightsail buckets.</p>
- *
- *          <p>For more information about buckets, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/buckets-in-amazon-lightsail">Buckets in Amazon Lightsail</a> in the <i>Amazon Lightsail Developer
- *         Guide</i>..</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetBucketsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetBucketsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetBucketsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetBucketsCommandInput} for command's `input` shape.
- * @see {@link GetBucketsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetBucketsCommand extends $Command<GetBucketsCommandInput, GetBucketsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetBucketsCommandInput;
     constructor(input: GetBucketsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBucketsCommandInput, GetBucketsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetBundlesCommandInput extends GetBundlesRequest {
 }
 export interface GetBundlesCommandOutput extends GetBundlesResult, __MetadataBearer {
 }
-/**
- * <p>Returns the list of bundles that are available for purchase. A bundle describes the specs
- *       for your virtual private server (or <i>instance</i>).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetBundlesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetBundlesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetBundlesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetBundlesCommandInput} for command's `input` shape.
- * @see {@link GetBundlesCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetBundlesCommand extends $Command<GetBundlesCommandInput, GetBundlesCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetBundlesCommandInput;
     constructor(input: GetBundlesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBundlesCommandInput, GetBundlesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface GetCertificatesCommandInput extends GetCertificatesRequest {
 }
 export interface GetCertificatesCommandOutput extends GetCertificatesResult, __MetadataBearer {
 }
-/**
- * <p>Returns information about one or more Amazon Lightsail SSL/TLS certificates.</p>
- *          <note>
- *             <p>To get a summary of a certificate, ommit <code>includeCertificateDetails</code> from
- *         your request. The response will include only the certificate Amazon Resource Name (ARN),
- *         certificate name, domain name, and tags.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetCertificatesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetCertificatesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetCertificatesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetCertificatesCommandInput} for command's `input` shape.
- * @see {@link GetCertificatesCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetCertificatesCommand extends $Command<GetCertificatesCommandInput, GetCertificatesCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetCertificatesCommandInput;
     constructor(input: GetCertificatesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCertificatesCommandInput, GetCertificatesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetCloudFormationStackRecordsCommandInput extends GetCloudForma
 }
 export interface GetCloudFormationStackRecordsCommandOutput extends GetCloudFormationStackRecordsResult, __MetadataBearer {
 }
-/**
- * <p>Returns the CloudFormation stack record created as a result of the <code>create cloud
- *         formation stack</code> operation.</p>
- *          <p>An AWS CloudFormation stack is used to create a new Amazon EC2 instance from an exported Lightsail
- *       snapshot.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetCloudFormationStackRecordsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetCloudFormationStackRecordsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetCloudFormationStackRecordsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetCloudFormationStackRecordsCommandInput} for command's `input` shape.
- * @see {@link GetCloudFormationStackRecordsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetCloudFormationStackRecordsCommand extends $Command<GetCloudFormationStackRecordsCommandInput, GetCloudFormationStackRecordsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetCloudFormationStackRecordsCommandInput;
     constructor(input: GetCloudFormationStackRecordsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCloudFormationStackRecordsCommandInput, GetCloudFormationStackRecordsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface GetContactMethodsCommandInput extends GetContactMethodsRequest
 }
 export interface GetContactMethodsCommandOutput extends GetContactMethodsResult, __MetadataBearer {
 }
-/**
- * <p>Returns information about the configured contact methods. Specify a protocol in your
- *       request to return information about a specific contact method.</p>
- *          <p>A contact method is used to send you notifications about your Amazon Lightsail resources.
- *       You can add one email address and one mobile phone number contact method in each AWS Region.
- *       However, SMS text messaging is not supported in some AWS Regions, and SMS text messages
- *       cannot be sent to some countries/regions. For more information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-notifications">Notifications in Amazon Lightsail</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetContactMethodsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetContactMethodsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetContactMethodsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetContactMethodsCommandInput} for command's `input` shape.
- * @see {@link GetContactMethodsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetContactMethodsCommand extends $Command<GetContactMethodsCommandInput, GetContactMethodsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetContactMethodsCommandInput;
     constructor(input: GetContactMethodsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContactMethodsCommandInput, GetContactMethodsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,36 +6,11 @@ export interface GetContainerImagesCommandInput extends GetContainerImagesReques
 }
 export interface GetContainerImagesCommandOutput extends GetContainerImagesResult, __MetadataBearer {
 }
-/**
- * <p>Returns the container images that are registered to your Amazon Lightsail container
- *       service.</p>
- *
- *          <note>
- *             <p>If you created a deployment on your Lightsail container service that uses container
- *         images from a public registry like Docker Hub, those images are not returned as part of this
- *         action. Those images are not registered to your Lightsail container service.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetContainerImagesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetContainerImagesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetContainerImagesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetContainerImagesCommandInput} for command's `input` shape.
- * @see {@link GetContainerImagesCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetContainerImagesCommand extends $Command<GetContainerImagesCommandInput, GetContainerImagesCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetContainerImagesCommandInput;
     constructor(input: GetContainerImagesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContainerImagesCommandInput, GetContainerImagesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface GetContainerLogCommandInput extends GetContainerLogRequest {
 }
 export interface GetContainerLogCommandOutput extends GetContainerLogResult, __MetadataBearer {
 }
-/**
- * <p>Returns the log events of a container of your Amazon Lightsail container service.</p>
- *
- *          <p>If your container service has more than one node (i.e., a scale greater than 1), then the
- *       log events that are returned for the specified container are merged from all nodes on your
- *       container service.</p>
- *
- *          <note>
- *             <p>Container logs are retained for a certain amount of time. For more information, see
- *           <a href="https://docs.aws.amazon.com/general/latest/gr/lightsail.html">Amazon Lightsail
- *           endpoints and quotas</a> in the <i>AWS General Reference</i>.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetContainerLogCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetContainerLogCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetContainerLogCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetContainerLogCommandInput} for command's `input` shape.
- * @see {@link GetContainerLogCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetContainerLogCommand extends $Command<GetContainerLogCommandInput, GetContainerLogCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetContainerLogCommandInput;
     constructor(input: GetContainerLogCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContainerLogCommandInput, GetContainerLogCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,41 +6,11 @@ export interface GetContainerServiceDeploymentsCommandInput extends GetContainer
 }
 export interface GetContainerServiceDeploymentsCommandOutput extends GetContainerServiceDeploymentsResult, __MetadataBearer {
 }
-/**
- * <p>Returns the deployments for your Amazon Lightsail container service</p>
- *
- *          <p>A deployment specifies the settings, such as the ports and launch command, of containers
- *       that are deployed to your container service.</p>
- *
- *          <p>The deployments are ordered by version in ascending order. The newest version is listed at
- *       the top of the response.</p>
- *
- *          <note>
- *             <p>A set number of deployments are kept before the oldest one is replaced with the newest
- *         one. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/lightsail.html">Amazon Lightsail
- *           endpoints and quotas</a> in the <i>AWS General Reference</i>.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetContainerServiceDeploymentsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetContainerServiceDeploymentsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetContainerServiceDeploymentsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetContainerServiceDeploymentsCommandInput} for command's `input` shape.
- * @see {@link GetContainerServiceDeploymentsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetContainerServiceDeploymentsCommand extends $Command<GetContainerServiceDeploymentsCommandInput, GetContainerServiceDeploymentsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetContainerServiceDeploymentsCommandInput;
     constructor(input: GetContainerServiceDeploymentsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContainerServiceDeploymentsCommandInput, GetContainerServiceDeploymentsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface GetContainerServiceMetricDataCommandInput extends GetContainerS
 }
 export interface GetContainerServiceMetricDataCommandOutput extends GetContainerServiceMetricDataResult, __MetadataBearer {
 }
-/**
- * <p>Returns the data points of a specific metric of your Amazon Lightsail container
- *       service.</p>
- *
- *          <p>Metrics report the utilization of your resources. 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, GetContainerServiceMetricDataCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetContainerServiceMetricDataCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetContainerServiceMetricDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetContainerServiceMetricDataCommandInput} for command's `input` shape.
- * @see {@link GetContainerServiceMetricDataCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetContainerServiceMetricDataCommand extends $Command<GetContainerServiceMetricDataCommandInput, GetContainerServiceMetricDataCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetContainerServiceMetricDataCommandInput;
     constructor(input: GetContainerServiceMetricDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContainerServiceMetricDataCommandInput, GetContainerServiceMetricDataCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface GetContainerServicePowersCommandInput extends GetContainerServi
 }
 export interface GetContainerServicePowersCommandOutput extends GetContainerServicePowersResult, __MetadataBearer {
 }
-/**
- * <p>Returns the list of powers that can be specified for your Amazon Lightsail container
- *       services.</p>
- *
- *          <p>The power specifies the amount of memory, the number of vCPUs, and the base price of the
- *       container service.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetContainerServicePowersCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetContainerServicePowersCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetContainerServicePowersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetContainerServicePowersCommandInput} for command's `input` shape.
- * @see {@link GetContainerServicePowersCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetContainerServicePowersCommand extends $Command<GetContainerServicePowersCommandInput, GetContainerServicePowersCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetContainerServicePowersCommandInput;
     constructor(input: GetContainerServicePowersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContainerServicePowersCommandInput, GetContainerServicePowersCommandOutput>;
     private serialize;
     private deserialize;