@aws-sdk/client-lightsail 3.35.0 → 3.38.0

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

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

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

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

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

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

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

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

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

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

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

@@ -6,32 +6,11 @@ export interface GetDistributionBundlesCommandInput extends GetDistributionBundl
 }
 export interface GetDistributionBundlesCommandOutput extends GetDistributionBundlesResult, __MetadataBearer {
 }
-/**
- * <p>Returns the bundles that can be applied to your Amazon Lightsail content delivery network
- *       (CDN) distributions.</p>
- *          <p>A distribution bundle specifies the monthly network transfer quota and monthly cost of
- *       your dsitribution.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetDistributionBundlesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetDistributionBundlesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetDistributionBundlesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDistributionBundlesCommandInput} for command's `input` shape.
- * @see {@link GetDistributionBundlesCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDistributionBundlesCommand extends $Command<GetDistributionBundlesCommandInput, GetDistributionBundlesCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetDistributionBundlesCommandInput;
     constructor(input: GetDistributionBundlesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDistributionBundlesCommandInput, GetDistributionBundlesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetDistributionLatestCacheResetCommandInput extends GetDistribu
 }
 export interface GetDistributionLatestCacheResetCommandOutput extends GetDistributionLatestCacheResetResult, __MetadataBearer {
 }
-/**
- * <p>Returns the timestamp and status of the last cache reset of a specific Amazon Lightsail
- *       content delivery network (CDN) distribution.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetDistributionLatestCacheResetCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetDistributionLatestCacheResetCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetDistributionLatestCacheResetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDistributionLatestCacheResetCommandInput} for command's `input` shape.
- * @see {@link GetDistributionLatestCacheResetCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDistributionLatestCacheResetCommand extends $Command<GetDistributionLatestCacheResetCommandInput, GetDistributionLatestCacheResetCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetDistributionLatestCacheResetCommandInput;
     constructor(input: GetDistributionLatestCacheResetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDistributionLatestCacheResetCommandInput, GetDistributionLatestCacheResetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface GetDistributionMetricDataCommandInput extends GetDistributionMe
 }
 export interface GetDistributionMetricDataCommandOutput extends GetDistributionMetricDataResult, __MetadataBearer {
 }
-/**
- * <p>Returns the data points of a specific metric for an Amazon Lightsail content delivery
- *       network (CDN) distribution.</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, GetDistributionMetricDataCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetDistributionMetricDataCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetDistributionMetricDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDistributionMetricDataCommandInput} for command's `input` shape.
- * @see {@link GetDistributionMetricDataCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDistributionMetricDataCommand extends $Command<GetDistributionMetricDataCommandInput, GetDistributionMetricDataCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetDistributionMetricDataCommandInput;
     constructor(input: GetDistributionMetricDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDistributionMetricDataCommandInput, GetDistributionMetricDataCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,32 +6,11 @@ export interface GetExportSnapshotRecordsCommandInput extends GetExportSnapshotR
 }
 export interface GetExportSnapshotRecordsCommandOutput extends GetExportSnapshotRecordsResult, __MetadataBearer {
 }
-/**
- * <p>Returns all export snapshot records created as a result of the <code>export
- *         snapshot</code> operation.</p>
- *          <p>An export snapshot record can be used to create a new Amazon EC2 instance and its related
- *       resources with the <a>CreateCloudFormationStack</a> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetExportSnapshotRecordsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetExportSnapshotRecordsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetExportSnapshotRecordsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetExportSnapshotRecordsCommandInput} for command's `input` shape.
- * @see {@link GetExportSnapshotRecordsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetExportSnapshotRecordsCommand extends $Command<GetExportSnapshotRecordsCommandInput, GetExportSnapshotRecordsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetExportSnapshotRecordsCommandInput;
     constructor(input: GetExportSnapshotRecordsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetExportSnapshotRecordsCommandInput, GetExportSnapshotRecordsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface GetInstanceAccessDetailsCommandInput extends GetInstanceAccessD
 }
 export interface GetInstanceAccessDetailsCommandOutput extends GetInstanceAccessDetailsResult, __MetadataBearer {
 }
-/**
- * <p>Returns temporary SSH keys you can use to connect to a specific virtual private server, or
- *         <i>instance</i>.</p>
- *          <p>The <code>get instance access details</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, GetInstanceAccessDetailsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetInstanceAccessDetailsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetInstanceAccessDetailsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetInstanceAccessDetailsCommandInput} for command's `input` shape.
- * @see {@link GetInstanceAccessDetailsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetInstanceAccessDetailsCommand extends $Command<GetInstanceAccessDetailsCommandInput, GetInstanceAccessDetailsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetInstanceAccessDetailsCommandInput;
     constructor(input: GetInstanceAccessDetailsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetInstanceAccessDetailsCommandInput, GetInstanceAccessDetailsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,33 +6,11 @@ export interface GetInstanceMetricDataCommandInput extends GetInstanceMetricData
 }
 export interface GetInstanceMetricDataCommandOutput extends GetInstanceMetricDataResult, __MetadataBearer {
 }
-/**
- * <p>Returns the data points for the specified Amazon Lightsail instance metric, given an
- *       instance name.</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, GetInstanceMetricDataCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetInstanceMetricDataCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetInstanceMetricDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetInstanceMetricDataCommandInput} for command's `input` shape.
- * @see {@link GetInstanceMetricDataCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetInstanceMetricDataCommand extends $Command<GetInstanceMetricDataCommandInput, GetInstanceMetricDataCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetInstanceMetricDataCommandInput;
     constructor(input: GetInstanceMetricDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetInstanceMetricDataCommandInput, GetInstanceMetricDataCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetInstancePortStatesCommandInput extends GetInstancePortStates
 }
 export interface GetInstancePortStatesCommandOutput extends GetInstancePortStatesResult, __MetadataBearer {
 }
-/**
- * <p>Returns the firewall port states for a specific Amazon Lightsail instance, the IP addresses
- *       allowed to connect to the instance through the ports, and the protocol.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetInstancePortStatesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetInstancePortStatesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetInstancePortStatesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetInstancePortStatesCommandInput} for command's `input` shape.
- * @see {@link GetInstancePortStatesCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetInstancePortStatesCommand extends $Command<GetInstancePortStatesCommandInput, GetInstancePortStatesCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetInstancePortStatesCommandInput;
     constructor(input: GetInstancePortStatesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetInstancePortStatesCommandInput, GetInstancePortStatesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface GetInstanceStateCommandInput extends GetInstanceStateRequest {
 }
 export interface GetInstanceStateCommandOutput extends GetInstanceStateResult, __MetadataBearer {
 }
-/**
- * <p>Returns the state of a specific instance. Works on one instance at a time.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetInstanceStateCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetInstanceStateCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetInstanceStateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetInstanceStateCommandInput} for command's `input` shape.
- * @see {@link GetInstanceStateCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetInstanceStateCommand extends $Command<GetInstanceStateCommandInput, GetInstanceStateCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetInstanceStateCommandInput;
     constructor(input: GetInstanceStateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetInstanceStateCommandInput, GetInstanceStateCommandOutput>;
     private serialize;
     private deserialize;