@aws-sdk/client-lightsail 3.32.0 → 3.36.0

package/dist-types/commands/DeleteRelationalDatabaseSnapshotCommand.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 { DeleteRelationalDatabaseSnapshotRequest, DeleteRelationalDatabaseSnapshotResult } from "../models/models_0";
+export interface DeleteRelationalDatabaseSnapshotCommandInput extends DeleteRelationalDatabaseSnapshotRequest {
+}
+export interface DeleteRelationalDatabaseSnapshotCommandOutput extends DeleteRelationalDatabaseSnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>Deletes a database snapshot in Amazon Lightsail.</p>
+ *          <p>The <code>delete relational database snapshot</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, DeleteRelationalDatabaseSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DeleteRelationalDatabaseSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DeleteRelationalDatabaseSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteRelationalDatabaseSnapshotCommandInput} for command's `input` shape.
+ * @see {@link DeleteRelationalDatabaseSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteRelationalDatabaseSnapshotCommand extends $Command<DeleteRelationalDatabaseSnapshotCommandInput, DeleteRelationalDatabaseSnapshotCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DeleteRelationalDatabaseSnapshotCommandInput;
+    constructor(input: DeleteRelationalDatabaseSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRelationalDatabaseSnapshotCommandInput, DeleteRelationalDatabaseSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DetachCertificateFromDistributionCommand.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 { DetachCertificateFromDistributionRequest, DetachCertificateFromDistributionResult } from "../models/models_0";
+export interface DetachCertificateFromDistributionCommandInput extends DetachCertificateFromDistributionRequest {
+}
+export interface DetachCertificateFromDistributionCommandOutput extends DetachCertificateFromDistributionResult, __MetadataBearer {
+}
+/**
+ * <p>Detaches an SSL/TLS certificate from your Amazon Lightsail content delivery network (CDN)
+ *       distribution.</p>
+ *          <p>After the certificate is detached, your distribution stops accepting traffic for all of
+ *       the domains that are associated with the certificate.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, DetachCertificateFromDistributionCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DetachCertificateFromDistributionCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DetachCertificateFromDistributionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DetachCertificateFromDistributionCommandInput} for command's `input` shape.
+ * @see {@link DetachCertificateFromDistributionCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DetachCertificateFromDistributionCommand extends $Command<DetachCertificateFromDistributionCommandInput, DetachCertificateFromDistributionCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DetachCertificateFromDistributionCommandInput;
+    constructor(input: DetachCertificateFromDistributionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachCertificateFromDistributionCommandInput, DetachCertificateFromDistributionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DetachDiskCommand.d.ts

@@ -0,0 +1,40 @@
+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 { DetachDiskRequest, DetachDiskResult } from "../models/models_0";
+export interface DetachDiskCommandInput extends DetachDiskRequest {
+}
+export interface DetachDiskCommandOutput extends DetachDiskResult, __MetadataBearer {
+}
+/**
+ * <p>Detaches a stopped block storage disk from a Lightsail instance. Make sure to unmount
+ *       any file systems on the device within your operating system before stopping the instance and
+ *       detaching the disk.</p>
+ *          <p>The <code>detach disk</code> operation supports tag-based access control via resource tags
+ *       applied to the resource identified by <code>disk 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, DetachDiskCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DetachDiskCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DetachDiskCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DetachDiskCommandInput} for command's `input` shape.
+ * @see {@link DetachDiskCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DetachDiskCommand extends $Command<DetachDiskCommandInput, DetachDiskCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DetachDiskCommandInput;
+    constructor(input: DetachDiskCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachDiskCommandInput, DetachDiskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DetachInstancesFromLoadBalancerCommand.d.ts

@@ -0,0 +1,40 @@
+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 { DetachInstancesFromLoadBalancerRequest, DetachInstancesFromLoadBalancerResult } from "../models/models_0";
+export interface DetachInstancesFromLoadBalancerCommandInput extends DetachInstancesFromLoadBalancerRequest {
+}
+export interface DetachInstancesFromLoadBalancerCommandOutput extends DetachInstancesFromLoadBalancerResult, __MetadataBearer {
+}
+/**
+ * <p>Detaches the specified instances from a Lightsail load balancer.</p>
+ *          <p>This operation waits until the instances are no longer needed before they are detached
+ *       from the load balancer.</p>
+ *          <p>The <code>detach instances from load balancer</code> operation supports tag-based access
+ *       control via resource tags applied to the resource identified by <code>load balancer
+ *         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, DetachInstancesFromLoadBalancerCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DetachInstancesFromLoadBalancerCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DetachInstancesFromLoadBalancerCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DetachInstancesFromLoadBalancerCommandInput} for command's `input` shape.
+ * @see {@link DetachInstancesFromLoadBalancerCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DetachInstancesFromLoadBalancerCommand extends $Command<DetachInstancesFromLoadBalancerCommandInput, DetachInstancesFromLoadBalancerCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DetachInstancesFromLoadBalancerCommandInput;
+    constructor(input: DetachInstancesFromLoadBalancerCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachInstancesFromLoadBalancerCommandInput, DetachInstancesFromLoadBalancerCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DetachStaticIpCommand.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 { DetachStaticIpRequest, DetachStaticIpResult } from "../models/models_0";
+export interface DetachStaticIpCommandInput extends DetachStaticIpRequest {
+}
+export interface DetachStaticIpCommandOutput extends DetachStaticIpResult, __MetadataBearer {
+}
+/**
+ * <p>Detaches a static IP from the Amazon Lightsail instance to which it is attached.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, DetachStaticIpCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DetachStaticIpCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DetachStaticIpCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DetachStaticIpCommandInput} for command's `input` shape.
+ * @see {@link DetachStaticIpCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DetachStaticIpCommand extends $Command<DetachStaticIpCommandInput, DetachStaticIpCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DetachStaticIpCommandInput;
+    constructor(input: DetachStaticIpCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachStaticIpCommandInput, DetachStaticIpCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DisableAddOnCommand.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 { DisableAddOnRequest, DisableAddOnResult } from "../models/models_0";
+export interface DisableAddOnCommandInput extends DisableAddOnRequest {
+}
+export interface DisableAddOnCommandOutput extends DisableAddOnResult, __MetadataBearer {
+}
+/**
+ * <p>Disables an add-on for an Amazon Lightsail resource. For more information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-configuring-automatic-snapshots">Amazon Lightsail Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, DisableAddOnCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DisableAddOnCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DisableAddOnCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisableAddOnCommandInput} for command's `input` shape.
+ * @see {@link DisableAddOnCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DisableAddOnCommand extends $Command<DisableAddOnCommandInput, DisableAddOnCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DisableAddOnCommandInput;
+    constructor(input: DisableAddOnCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableAddOnCommandInput, DisableAddOnCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/EnableAddOnCommand.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 { EnableAddOnRequest, EnableAddOnResult } from "../models/models_0";
+export interface EnableAddOnCommandInput extends EnableAddOnRequest {
+}
+export interface EnableAddOnCommandOutput extends EnableAddOnResult, __MetadataBearer {
+}
+/**
+ * <p>Enables or modifies an add-on for an Amazon Lightsail resource. For more information, see
+ *       the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-configuring-automatic-snapshots">Amazon Lightsail Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, EnableAddOnCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, EnableAddOnCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new EnableAddOnCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link EnableAddOnCommandInput} for command's `input` shape.
+ * @see {@link EnableAddOnCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class EnableAddOnCommand extends $Command<EnableAddOnCommandInput, EnableAddOnCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: EnableAddOnCommandInput;
+    constructor(input: EnableAddOnCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableAddOnCommandInput, EnableAddOnCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ExportSnapshotCommand.d.ts

@@ -0,0 +1,49 @@
+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 { ExportSnapshotRequest, ExportSnapshotResult } from "../models/models_0";
+export interface ExportSnapshotCommandInput extends ExportSnapshotRequest {
+}
+export interface ExportSnapshotCommandOutput extends ExportSnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>Exports an Amazon Lightsail instance or block storage disk snapshot to Amazon Elastic Compute Cloud (Amazon EC2).
+ *       This operation results in an export snapshot record that can be used with the <code>create
+ *         cloud formation stack</code> operation to create new Amazon EC2 instances.</p>
+ *          <p>Exported instance snapshots appear in Amazon EC2 as Amazon Machine Images (AMIs), and the
+ *       instance system disk appears as an Amazon Elastic Block Store (Amazon EBS) volume. Exported disk snapshots appear in
+ *       Amazon EC2 as Amazon EBS volumes. Snapshots are exported to the same Amazon Web Services Region in Amazon EC2 as the
+ *       source Lightsail snapshot.</p>
+ *          <p></p>
+ *          <p>The <code>export snapshot</code> operation supports tag-based access control via resource
+ *       tags applied to the resource identified by <code>source snapshot 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>
+ *          <note>
+ *             <p>Use the <code>get instance snapshots</code> or <code>get disk snapshots</code>
+ *         operations to get a list of snapshots that you can export to Amazon EC2.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, ExportSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, ExportSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new ExportSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ExportSnapshotCommandInput} for command's `input` shape.
+ * @see {@link ExportSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ExportSnapshotCommand extends $Command<ExportSnapshotCommandInput, ExportSnapshotCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: ExportSnapshotCommandInput;
+    constructor(input: ExportSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExportSnapshotCommandInput, ExportSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetActiveNamesCommand.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 { GetActiveNamesRequest, GetActiveNamesResult } from "../models/models_0";
+export interface GetActiveNamesCommandInput extends GetActiveNamesRequest {
+}
+export interface GetActiveNamesCommandOutput extends GetActiveNamesResult, __MetadataBearer {
+}
+/**
+ * <p>Returns the names of all active (not deleted) resources.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, GetActiveNamesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetActiveNamesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetActiveNamesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetActiveNamesCommandInput} for command's `input` shape.
+ * @see {@link GetActiveNamesCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetActiveNamesCommand extends $Command<GetActiveNamesCommandInput, GetActiveNamesCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetActiveNamesCommandInput;
+    constructor(input: GetActiveNamesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetActiveNamesCommandInput, GetActiveNamesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

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

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

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

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

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