@aws-sdk/client-lightsail 3.35.0 → 3.38.0

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

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

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

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

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

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

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

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

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

@@ -6,32 +6,11 @@ export interface GetLoadBalancerMetricDataCommandInput extends GetLoadBalancerMe
 }
 export interface GetLoadBalancerMetricDataCommandOutput extends GetLoadBalancerMetricDataResult, __MetadataBearer {
 }
-/**
- * <p>Returns information about health metrics for your Lightsail load balancer.</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, GetLoadBalancerMetricDataCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetLoadBalancerMetricDataCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetLoadBalancerMetricDataCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetLoadBalancerMetricDataCommandInput} for command's `input` shape.
- * @see {@link GetLoadBalancerMetricDataCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetLoadBalancerMetricDataCommand extends $Command<GetLoadBalancerMetricDataCommandInput, GetLoadBalancerMetricDataCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetLoadBalancerMetricDataCommandInput;
     constructor(input: GetLoadBalancerMetricDataCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLoadBalancerMetricDataCommandInput, GetLoadBalancerMetricDataCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface GetLoadBalancerTlsCertificatesCommandInput extends GetLoadBalan
 }
 export interface GetLoadBalancerTlsCertificatesCommandOutput extends GetLoadBalancerTlsCertificatesResult, __MetadataBearer {
 }
-/**
- * <p>Returns information about the TLS certificates that are associated with the specified
- *       Lightsail load balancer.</p>
- *          <p>TLS is just an updated, more secure version of Secure Socket Layer (SSL).</p>
- *          <p>You can have a maximum of 2 certificates associated with a Lightsail load balancer. One
- *       is active and the other is inactive.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetLoadBalancerTlsCertificatesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetLoadBalancerTlsCertificatesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetLoadBalancerTlsCertificatesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetLoadBalancerTlsCertificatesCommandInput} for command's `input` shape.
- * @see {@link GetLoadBalancerTlsCertificatesCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetLoadBalancerTlsCertificatesCommand extends $Command<GetLoadBalancerTlsCertificatesCommandInput, GetLoadBalancerTlsCertificatesCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetLoadBalancerTlsCertificatesCommandInput;
     constructor(input: GetLoadBalancerTlsCertificatesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLoadBalancerTlsCertificatesCommandInput, GetLoadBalancerTlsCertificatesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface GetOperationCommandInput extends GetOperationRequest {
 }
 export interface GetOperationCommandOutput extends GetOperationResult, __MetadataBearer {
 }
-/**
- * <p>Returns information about a specific operation. Operations include events such as when you
- *       create an instance, allocate a static IP, attach a static IP, and so on.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetOperationCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetOperationCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetOperationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetOperationCommandInput} for command's `input` shape.
- * @see {@link GetOperationCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetOperationCommand extends $Command<GetOperationCommandInput, GetOperationCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetOperationCommandInput;
     constructor(input: GetOperationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetOperationCommandInput, GetOperationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetOperationsCommandInput extends GetOperationsRequest {
 }
 export interface GetOperationsCommandOutput extends GetOperationsResult, __MetadataBearer {
 }
-/**
- * <p>Returns information about all operations.</p>
- *          <p>Results are returned from oldest to newest, up to a maximum of 200. Results can be paged
- *       by making each subsequent call to <code>GetOperations</code> use the maximum (last)
- *         <code>statusChangedAt</code> value from the previous request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetOperationsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetOperationsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetOperationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetOperationsCommandInput} for command's `input` shape.
- * @see {@link GetOperationsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetOperationsCommand extends $Command<GetOperationsCommandInput, GetOperationsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetOperationsCommandInput;
     constructor(input: GetOperationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetOperationsCommandInput, GetOperationsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface GetRegionsCommandInput extends GetRegionsRequest {
 }
 export interface GetRegionsCommandOutput extends GetRegionsResult, __MetadataBearer {
 }
-/**
- * <p>Returns a list of all valid regions for Amazon Lightsail. Use the <code>include
- *         availability zones</code> parameter to also return the Availability Zones in a
- *       region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetRegionsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetRegionsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetRegionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRegionsCommandInput} for command's `input` shape.
- * @see {@link GetRegionsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRegionsCommand extends $Command<GetRegionsCommandInput, GetRegionsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetRegionsCommandInput;
     constructor(input: GetRegionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRegionsCommandInput, GetRegionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetRelationalDatabaseBlueprintsCommandInput extends GetRelation
 }
 export interface GetRelationalDatabaseBlueprintsCommandOutput extends GetRelationalDatabaseBlueprintsResult, __MetadataBearer {
 }
-/**
- * <p>Returns a list of available database blueprints in Amazon Lightsail. A blueprint describes
- *       the major engine version of a database.</p>
- *          <p>You can use a blueprint ID to create a new database that runs a specific database
- *       engine.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetRelationalDatabaseBlueprintsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetRelationalDatabaseBlueprintsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetRelationalDatabaseBlueprintsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRelationalDatabaseBlueprintsCommandInput} for command's `input` shape.
- * @see {@link GetRelationalDatabaseBlueprintsCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRelationalDatabaseBlueprintsCommand extends $Command<GetRelationalDatabaseBlueprintsCommandInput, GetRelationalDatabaseBlueprintsCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetRelationalDatabaseBlueprintsCommandInput;
     constructor(input: GetRelationalDatabaseBlueprintsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRelationalDatabaseBlueprintsCommandInput, GetRelationalDatabaseBlueprintsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetRelationalDatabaseBundlesCommandInput extends GetRelationalD
 }
 export interface GetRelationalDatabaseBundlesCommandOutput extends GetRelationalDatabaseBundlesResult, __MetadataBearer {
 }
-/**
- * <p>Returns the list of bundles that are available in Amazon Lightsail. A bundle describes the
- *       performance specifications for a database.</p>
- *          <p>You can use a bundle ID to create a new database with explicit performance
- *       specifications.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetRelationalDatabaseBundlesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetRelationalDatabaseBundlesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetRelationalDatabaseBundlesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRelationalDatabaseBundlesCommandInput} for command's `input` shape.
- * @see {@link GetRelationalDatabaseBundlesCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRelationalDatabaseBundlesCommand extends $Command<GetRelationalDatabaseBundlesCommandInput, GetRelationalDatabaseBundlesCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetRelationalDatabaseBundlesCommandInput;
     constructor(input: GetRelationalDatabaseBundlesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRelationalDatabaseBundlesCommandInput, GetRelationalDatabaseBundlesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

@@ -6,33 +6,11 @@ export interface GetRelationalDatabaseMasterUserPasswordCommandInput extends Get
 }
 export interface GetRelationalDatabaseMasterUserPasswordCommandOutput extends GetRelationalDatabaseMasterUserPasswordResult, __MetadataBearer {
 }
-/**
- * <p>Returns the current, previous, or pending versions of the master user password for a
- *       Lightsail database.</p>
- *          <p>The <code>GetRelationalDatabaseMasterUserPassword</code> operation supports tag-based
- *       access control via resource tags applied to the resource identified by
- *       relationalDatabaseName.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, GetRelationalDatabaseMasterUserPasswordCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, GetRelationalDatabaseMasterUserPasswordCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new GetRelationalDatabaseMasterUserPasswordCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRelationalDatabaseMasterUserPasswordCommandInput} for command's `input` shape.
- * @see {@link GetRelationalDatabaseMasterUserPasswordCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRelationalDatabaseMasterUserPasswordCommand extends $Command<GetRelationalDatabaseMasterUserPasswordCommandInput, GetRelationalDatabaseMasterUserPasswordCommandOutput, LightsailClientResolvedConfig> {
     readonly input: GetRelationalDatabaseMasterUserPasswordCommandInput;
     constructor(input: GetRelationalDatabaseMasterUserPasswordCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRelationalDatabaseMasterUserPasswordCommandInput, GetRelationalDatabaseMasterUserPasswordCommandOutput>;
     private serialize;
     private deserialize;