@aws-sdk/client-lightsail 3.32.0 → 3.36.0

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

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

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

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

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

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

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

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

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

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

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

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

@@ -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 { GetStaticIpsRequest, GetStaticIpsResult } from "../models/models_1";
+export interface GetStaticIpsCommandInput extends GetStaticIpsRequest {
+}
+export interface GetStaticIpsCommandOutput extends GetStaticIpsResult, __MetadataBearer {
+}
+/**
+ * <p>Returns information about all static IPs in the user's account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, GetStaticIpsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetStaticIpsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetStaticIpsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetStaticIpsCommandInput} for command's `input` shape.
+ * @see {@link GetStaticIpsCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetStaticIpsCommand extends $Command<GetStaticIpsCommandInput, GetStaticIpsCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetStaticIpsCommandInput;
+    constructor(input: GetStaticIpsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetStaticIpsCommandInput, GetStaticIpsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -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 { ImportKeyPairRequest, ImportKeyPairResult } from "../models/models_1";
+export interface ImportKeyPairCommandInput extends ImportKeyPairRequest {
+}
+export interface ImportKeyPairCommandOutput extends ImportKeyPairResult, __MetadataBearer {
+}
+/**
+ * <p>Imports a public SSH key from a specific key pair.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, ImportKeyPairCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, ImportKeyPairCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new ImportKeyPairCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ImportKeyPairCommandInput} for command's `input` shape.
+ * @see {@link ImportKeyPairCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ImportKeyPairCommand extends $Command<ImportKeyPairCommandInput, ImportKeyPairCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: ImportKeyPairCommandInput;
+    constructor(input: ImportKeyPairCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportKeyPairCommandInput, ImportKeyPairCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -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 { IsVpcPeeredRequest, IsVpcPeeredResult } from "../models/models_1";
+export interface IsVpcPeeredCommandInput extends IsVpcPeeredRequest {
+}
+export interface IsVpcPeeredCommandOutput extends IsVpcPeeredResult, __MetadataBearer {
+}
+/**
+ * <p>Returns a Boolean value indicating whether your Lightsail VPC is peered.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, IsVpcPeeredCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, IsVpcPeeredCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new IsVpcPeeredCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link IsVpcPeeredCommandInput} for command's `input` shape.
+ * @see {@link IsVpcPeeredCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class IsVpcPeeredCommand extends $Command<IsVpcPeeredCommandInput, IsVpcPeeredCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: IsVpcPeeredCommandInput;
+    constructor(input: IsVpcPeeredCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<IsVpcPeeredCommandInput, IsVpcPeeredCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -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 { OpenInstancePublicPortsRequest, OpenInstancePublicPortsResult } from "../models/models_1";
+export interface OpenInstancePublicPortsCommandInput extends OpenInstancePublicPortsRequest {
+}
+export interface OpenInstancePublicPortsCommandOutput extends OpenInstancePublicPortsResult, __MetadataBearer {
+}
+/**
+ * <p>Opens ports for a specific Amazon Lightsail instance, and specifies the IP addresses
+ *       allowed to connect to the instance through the ports, and the protocol.</p>
+ *          <p>The <code>OpenInstancePublicPorts</code> action supports tag-based access control via
+ *       resource tags applied to the resource identified by <code>instanceName</code>. For more
+ *       information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, OpenInstancePublicPortsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, OpenInstancePublicPortsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new OpenInstancePublicPortsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link OpenInstancePublicPortsCommandInput} for command's `input` shape.
+ * @see {@link OpenInstancePublicPortsCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class OpenInstancePublicPortsCommand extends $Command<OpenInstancePublicPortsCommandInput, OpenInstancePublicPortsCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: OpenInstancePublicPortsCommandInput;
+    constructor(input: OpenInstancePublicPortsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<OpenInstancePublicPortsCommandInput, OpenInstancePublicPortsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -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 { PeerVpcRequest, PeerVpcResult } from "../models/models_1";
+export interface PeerVpcCommandInput extends PeerVpcRequest {
+}
+export interface PeerVpcCommandOutput extends PeerVpcResult, __MetadataBearer {
+}
+/**
+ * <p>Peers the Lightsail VPC with the user's default VPC.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, PeerVpcCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, PeerVpcCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new PeerVpcCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PeerVpcCommandInput} for command's `input` shape.
+ * @see {@link PeerVpcCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PeerVpcCommand extends $Command<PeerVpcCommandInput, PeerVpcCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: PeerVpcCommandInput;
+    constructor(input: PeerVpcCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PeerVpcCommandInput, PeerVpcCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

@@ -0,0 +1,43 @@
+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 { PutInstancePublicPortsRequest, PutInstancePublicPortsResult } from "../models/models_1";
+export interface PutInstancePublicPortsCommandInput extends PutInstancePublicPortsRequest {
+}
+export interface PutInstancePublicPortsCommandOutput extends PutInstancePublicPortsResult, __MetadataBearer {
+}
+/**
+ * <p>Opens ports for a specific Amazon Lightsail instance, and specifies the IP addresses
+ *       allowed to connect to the instance through the ports, and the protocol. This action also
+ *       closes all currently open ports that are not included in the request. Include all of the ports
+ *       and the protocols you want to open in your <code>PutInstancePublicPorts</code>request. Or use
+ *       the <code>OpenInstancePublicPorts</code> action to open ports without closing currently open
+ *       ports.</p>
+ *          <p>The <code>PutInstancePublicPorts</code> action supports tag-based access control via
+ *       resource tags applied to the resource identified by <code>instanceName</code>. For more
+ *       information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, PutInstancePublicPortsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, PutInstancePublicPortsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new PutInstancePublicPortsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutInstancePublicPortsCommandInput} for command's `input` shape.
+ * @see {@link PutInstancePublicPortsCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutInstancePublicPortsCommand extends $Command<PutInstancePublicPortsCommandInput, PutInstancePublicPortsCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: PutInstancePublicPortsCommandInput;
+    constructor(input: PutInstancePublicPortsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutInstancePublicPortsCommandInput, PutInstancePublicPortsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -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 { RebootInstanceRequest, RebootInstanceResult } from "../models/models_1";
+export interface RebootInstanceCommandInput extends RebootInstanceRequest {
+}
+export interface RebootInstanceCommandOutput extends RebootInstanceResult, __MetadataBearer {
+}
+/**
+ * <p>Restarts a specific instance.</p>
+ *          <p>The <code>reboot instance</code> operation supports tag-based access control via resource
+ *       tags applied to the resource identified by <code>instance name</code>. For more information,
+ *       see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, RebootInstanceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, RebootInstanceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new RebootInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RebootInstanceCommandInput} for command's `input` shape.
+ * @see {@link RebootInstanceCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RebootInstanceCommand extends $Command<RebootInstanceCommandInput, RebootInstanceCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: RebootInstanceCommandInput;
+    constructor(input: RebootInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RebootInstanceCommandInput, RebootInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -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 { RebootRelationalDatabaseRequest, RebootRelationalDatabaseResult } from "../models/models_1";
+export interface RebootRelationalDatabaseCommandInput extends RebootRelationalDatabaseRequest {
+}
+export interface RebootRelationalDatabaseCommandOutput extends RebootRelationalDatabaseResult, __MetadataBearer {
+}
+/**
+ * <p>Restarts a specific database in Amazon Lightsail.</p>
+ *          <p>The <code>reboot relational database</code> operation supports tag-based access control
+ *       via resource tags applied to the resource identified by relationalDatabaseName. For more
+ *       information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Amazon Lightsail Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, RebootRelationalDatabaseCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, RebootRelationalDatabaseCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new RebootRelationalDatabaseCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RebootRelationalDatabaseCommandInput} for command's `input` shape.
+ * @see {@link RebootRelationalDatabaseCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RebootRelationalDatabaseCommand extends $Command<RebootRelationalDatabaseCommandInput, RebootRelationalDatabaseCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: RebootRelationalDatabaseCommandInput;
+    constructor(input: RebootRelationalDatabaseCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RebootRelationalDatabaseCommandInput, RebootRelationalDatabaseCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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