@aws-sdk/client-lightsail 3.32.0 → 3.36.0

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetKeyPairsRequest, GetKeyPairsResult } from "../models/models_1";
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetLoadBalancerRequest, GetLoadBalancerResult } from "../models/models_1";
+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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetLoadBalancerMetricDataRequest, GetLoadBalancerMetricDataResult } from "../models/models_1";
+export interface GetLoadBalancerMetricDataCommandInput extends GetLoadBalancerMetricDataRequest {
+}
+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

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetLoadBalancerTlsCertificatesRequest, GetLoadBalancerTlsCertificatesResult } from "../models/models_1";
+export interface GetLoadBalancerTlsCertificatesCommandInput extends GetLoadBalancerTlsCertificatesRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetLoadBalancersRequest, GetLoadBalancersResult } from "../models/models_1";
+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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetOperationRequest, GetOperationResult } from "../models/models_1";
+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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetOperationsRequest, GetOperationsResult } from "../models/models_1";
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetOperationsForResourceRequest, GetOperationsForResourceResult } from "../models/models_1";
+export interface GetOperationsForResourceCommandInput extends GetOperationsForResourceRequest {
+}
+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

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetRegionsRequest, GetRegionsResult } from "../models/models_1";
+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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetRelationalDatabaseBlueprintsRequest, GetRelationalDatabaseBlueprintsResult } from "../models/models_1";
+export interface GetRelationalDatabaseBlueprintsCommandInput extends GetRelationalDatabaseBlueprintsRequest {
+}
+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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetRelationalDatabaseBundlesRequest, GetRelationalDatabaseBundlesResult } from "../models/models_1";
+export interface GetRelationalDatabaseBundlesCommandInput extends GetRelationalDatabaseBundlesRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetRelationalDatabaseRequest, GetRelationalDatabaseResult } from "../models/models_1";
+export interface GetRelationalDatabaseCommandInput extends GetRelationalDatabaseRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetRelationalDatabaseEventsRequest, GetRelationalDatabaseEventsResult } from "../models/models_1";
+export interface GetRelationalDatabaseEventsCommandInput extends GetRelationalDatabaseEventsRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetRelationalDatabaseLogEventsRequest, GetRelationalDatabaseLogEventsResult } from "../models/models_1";
+export interface GetRelationalDatabaseLogEventsCommandInput extends GetRelationalDatabaseLogEventsRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetRelationalDatabaseLogStreamsRequest, GetRelationalDatabaseLogStreamsResult } from "../models/models_1";
+export interface GetRelationalDatabaseLogStreamsCommandInput extends GetRelationalDatabaseLogStreamsRequest {
+}
+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

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { GetRelationalDatabaseMasterUserPasswordRequest, GetRelationalDatabaseMasterUserPasswordResult } from "../models/models_1";
+export interface GetRelationalDatabaseMasterUserPasswordCommandInput extends GetRelationalDatabaseMasterUserPasswordRequest {
+}
+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;
+}