@aws-sdk/client-lightsail 3.32.0 → 3.36.0

package/dist/types/ts3.4/commands/CreateDomainEntryCommand.d.ts

@@ -1,43 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { CreateDomainEntryRequest, CreateDomainEntryResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateDomainEntryCommandInput extends CreateDomainEntryRequest {
-}
-export interface CreateDomainEntryCommandOutput extends CreateDomainEntryResult, __MetadataBearer {
-}
-/**
- * <p>Creates one of the following domain name system (DNS) records in a domain DNS zone:
- *       Address (A), canonical name (CNAME), mail exchanger (MX), name server (NS), start of authority
- *       (SOA), service locator (SRV), or text (TXT).</p>
- *
- *
- *
- *          <p>The <code>create domain entry</code> operation supports tag-based access control via
- *       resource tags applied to the resource identified by <code>domain 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, CreateDomainEntryCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateDomainEntryCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateDomainEntryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDomainEntryCommandInput} for command's `input` shape.
- * @see {@link CreateDomainEntryCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateDomainEntryCommand extends $Command<CreateDomainEntryCommandInput, CreateDomainEntryCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: CreateDomainEntryCommandInput;
-    constructor(input: CreateDomainEntryCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDomainEntryCommandInput, CreateDomainEntryCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateInstanceSnapshotCommand.d.ts

@@ -1,38 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { CreateInstanceSnapshotRequest, CreateInstanceSnapshotResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateInstanceSnapshotCommandInput extends CreateInstanceSnapshotRequest {
-}
-export interface CreateInstanceSnapshotCommandOutput extends CreateInstanceSnapshotResult, __MetadataBearer {
-}
-/**
- * <p>Creates a snapshot of a specific virtual private server, or <i>instance</i>.
- *       You can use a snapshot to create a new instance that is based on that snapshot.</p>
- *          <p>The <code>create instance snapshot</code> operation supports tag-based access control via
- *       request tags. 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, CreateInstanceSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateInstanceSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateInstanceSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateInstanceSnapshotCommandInput} for command's `input` shape.
- * @see {@link CreateInstanceSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateInstanceSnapshotCommand extends $Command<CreateInstanceSnapshotCommandInput, CreateInstanceSnapshotCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: CreateInstanceSnapshotCommandInput;
-    constructor(input: CreateInstanceSnapshotCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstanceSnapshotCommandInput, CreateInstanceSnapshotCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateInstancesCommand.d.ts

@@ -1,37 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { CreateInstancesRequest, CreateInstancesResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateInstancesCommandInput extends CreateInstancesRequest {
-}
-export interface CreateInstancesCommandOutput extends CreateInstancesResult, __MetadataBearer {
-}
-/**
- * <p>Creates one or more Amazon Lightsail instances.</p>
- *          <p>The <code>create instances</code> operation supports tag-based access control via request
- *       tags. For more information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags">Lightsail Developer Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, CreateInstancesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateInstancesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateInstancesCommandInput} for command's `input` shape.
- * @see {@link CreateInstancesCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateInstancesCommand extends $Command<CreateInstancesCommandInput, CreateInstancesCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: CreateInstancesCommandInput;
-    constructor(input: CreateInstancesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstancesCommandInput, CreateInstancesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateInstancesFromSnapshotCommand.d.ts

@@ -1,39 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { CreateInstancesFromSnapshotRequest, CreateInstancesFromSnapshotResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateInstancesFromSnapshotCommandInput extends CreateInstancesFromSnapshotRequest {
-}
-export interface CreateInstancesFromSnapshotCommandOutput extends CreateInstancesFromSnapshotResult, __MetadataBearer {
-}
-/**
- * <p>Creates one or more new instances from a manual or automatic snapshot of an
- *       instance.</p>
- *          <p>The <code>create instances from snapshot</code> operation supports tag-based access
- *       control via request tags and resource tags applied to the resource identified by
- *         <code>instance 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, CreateInstancesFromSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateInstancesFromSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateInstancesFromSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateInstancesFromSnapshotCommandInput} for command's `input` shape.
- * @see {@link CreateInstancesFromSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateInstancesFromSnapshotCommand extends $Command<CreateInstancesFromSnapshotCommandInput, CreateInstancesFromSnapshotCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: CreateInstancesFromSnapshotCommandInput;
-    constructor(input: CreateInstancesFromSnapshotCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInstancesFromSnapshotCommandInput, CreateInstancesFromSnapshotCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateKeyPairCommand.d.ts

@@ -1,37 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { CreateKeyPairRequest, CreateKeyPairResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateKeyPairCommandInput extends CreateKeyPairRequest {
-}
-export interface CreateKeyPairCommandOutput extends CreateKeyPairResult, __MetadataBearer {
-}
-/**
- * <p>Creates an SSH key pair.</p>
- *          <p>The <code>create key pair</code> operation supports tag-based access control via request
- *       tags. 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, CreateKeyPairCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateKeyPairCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateKeyPairCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateKeyPairCommandInput} for command's `input` shape.
- * @see {@link CreateKeyPairCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateKeyPairCommand extends $Command<CreateKeyPairCommandInput, CreateKeyPairCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: CreateKeyPairCommandInput;
-    constructor(input: CreateKeyPairCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateKeyPairCommandInput, CreateKeyPairCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateLoadBalancerCommand.d.ts

@@ -1,42 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { CreateLoadBalancerRequest, CreateLoadBalancerResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateLoadBalancerCommandInput extends CreateLoadBalancerRequest {
-}
-export interface CreateLoadBalancerCommandOutput extends CreateLoadBalancerResult, __MetadataBearer {
-}
-/**
- * <p>Creates a Lightsail load balancer. To learn more about deciding whether to load balance
- *       your application, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/configure-lightsail-instances-for-load-balancing">Configure your Lightsail instances for load balancing</a>. You can create up to 5
- *       load balancers per AWS Region in your account.</p>
- *          <p>When you create a load balancer, you can specify a unique name and port settings. To
- *       change additional load balancer settings, use the <code>UpdateLoadBalancerAttribute</code>
- *       operation.</p>
- *          <p>The <code>create load balancer</code> operation supports tag-based access control via
- *       request tags. 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, CreateLoadBalancerCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateLoadBalancerCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateLoadBalancerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLoadBalancerCommandInput} for command's `input` shape.
- * @see {@link CreateLoadBalancerCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateLoadBalancerCommand extends $Command<CreateLoadBalancerCommandInput, CreateLoadBalancerCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: CreateLoadBalancerCommandInput;
-    constructor(input: CreateLoadBalancerCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoadBalancerCommandInput, CreateLoadBalancerCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateLoadBalancerTlsCertificateCommand.d.ts

@@ -1,39 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { CreateLoadBalancerTlsCertificateRequest, CreateLoadBalancerTlsCertificateResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateLoadBalancerTlsCertificateCommandInput extends CreateLoadBalancerTlsCertificateRequest {
-}
-export interface CreateLoadBalancerTlsCertificateCommandOutput extends CreateLoadBalancerTlsCertificateResult, __MetadataBearer {
-}
-/**
- * <p>Creates an SSL/TLS certificate for an Amazon Lightsail load balancer.</p>
- *          <p>TLS is just an updated, more secure version of Secure Socket Layer (SSL).</p>
- *          <p>The <code>CreateLoadBalancerTlsCertificate</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, CreateLoadBalancerTlsCertificateCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateLoadBalancerTlsCertificateCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateLoadBalancerTlsCertificateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLoadBalancerTlsCertificateCommandInput} for command's `input` shape.
- * @see {@link CreateLoadBalancerTlsCertificateCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateLoadBalancerTlsCertificateCommand extends $Command<CreateLoadBalancerTlsCertificateCommandInput, CreateLoadBalancerTlsCertificateCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: CreateLoadBalancerTlsCertificateCommandInput;
-    constructor(input: CreateLoadBalancerTlsCertificateCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoadBalancerTlsCertificateCommandInput, CreateLoadBalancerTlsCertificateCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateRelationalDatabaseCommand.d.ts

@@ -1,37 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { CreateRelationalDatabaseRequest, CreateRelationalDatabaseResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateRelationalDatabaseCommandInput extends CreateRelationalDatabaseRequest {
-}
-export interface CreateRelationalDatabaseCommandOutput extends CreateRelationalDatabaseResult, __MetadataBearer {
-}
-/**
- * <p>Creates a new database in Amazon Lightsail.</p>
- *          <p>The <code>create relational database</code> operation supports tag-based access control
- *       via request tags. 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, CreateRelationalDatabaseCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateRelationalDatabaseCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateRelationalDatabaseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateRelationalDatabaseCommandInput} for command's `input` shape.
- * @see {@link CreateRelationalDatabaseCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateRelationalDatabaseCommand extends $Command<CreateRelationalDatabaseCommandInput, CreateRelationalDatabaseCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: CreateRelationalDatabaseCommandInput;
-    constructor(input: CreateRelationalDatabaseCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRelationalDatabaseCommandInput, CreateRelationalDatabaseCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateRelationalDatabaseFromSnapshotCommand.d.ts

@@ -1,41 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { CreateRelationalDatabaseFromSnapshotRequest, CreateRelationalDatabaseFromSnapshotResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateRelationalDatabaseFromSnapshotCommandInput extends CreateRelationalDatabaseFromSnapshotRequest {
-}
-export interface CreateRelationalDatabaseFromSnapshotCommandOutput extends CreateRelationalDatabaseFromSnapshotResult, __MetadataBearer {
-}
-/**
- * <p>Creates a new database from an existing database snapshot in Amazon Lightsail.</p>
- *          <p>You can create a new database from a snapshot in if something goes wrong with your
- *       original database, or to change it to a different plan, such as a high availability or
- *       standard plan.</p>
- *          <p>The <code>create relational database from snapshot</code> operation supports tag-based
- *       access control via request tags and resource tags applied to the resource identified by
- *       relationalDatabaseSnapshotName. 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, CreateRelationalDatabaseFromSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateRelationalDatabaseFromSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateRelationalDatabaseFromSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateRelationalDatabaseFromSnapshotCommandInput} for command's `input` shape.
- * @see {@link CreateRelationalDatabaseFromSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateRelationalDatabaseFromSnapshotCommand extends $Command<CreateRelationalDatabaseFromSnapshotCommandInput, CreateRelationalDatabaseFromSnapshotCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: CreateRelationalDatabaseFromSnapshotCommandInput;
-    constructor(input: CreateRelationalDatabaseFromSnapshotCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRelationalDatabaseFromSnapshotCommandInput, CreateRelationalDatabaseFromSnapshotCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateRelationalDatabaseSnapshotCommand.d.ts

@@ -1,38 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { CreateRelationalDatabaseSnapshotRequest, CreateRelationalDatabaseSnapshotResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateRelationalDatabaseSnapshotCommandInput extends CreateRelationalDatabaseSnapshotRequest {
-}
-export interface CreateRelationalDatabaseSnapshotCommandOutput extends CreateRelationalDatabaseSnapshotResult, __MetadataBearer {
-}
-/**
- * <p>Creates a snapshot of your database in Amazon Lightsail. You can use snapshots for backups,
- *       to make copies of a database, and to save data before deleting a database.</p>
- *          <p>The <code>create relational database snapshot</code> operation supports tag-based access
- *       control via request tags. 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, CreateRelationalDatabaseSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, CreateRelationalDatabaseSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new CreateRelationalDatabaseSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateRelationalDatabaseSnapshotCommandInput} for command's `input` shape.
- * @see {@link CreateRelationalDatabaseSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateRelationalDatabaseSnapshotCommand extends $Command<CreateRelationalDatabaseSnapshotCommandInput, CreateRelationalDatabaseSnapshotCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: CreateRelationalDatabaseSnapshotCommandInput;
-    constructor(input: CreateRelationalDatabaseSnapshotCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRelationalDatabaseSnapshotCommandInput, CreateRelationalDatabaseSnapshotCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteAlarmCommand.d.ts

@@ -1,39 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { DeleteAlarmRequest, DeleteAlarmResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteAlarmCommandInput extends DeleteAlarmRequest {
-}
-export interface DeleteAlarmCommandOutput extends DeleteAlarmResult, __MetadataBearer {
-}
-/**
- * <p>Deletes an alarm.</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, DeleteAlarmCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteAlarmCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteAlarmCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteAlarmCommandInput} for command's `input` shape.
- * @see {@link DeleteAlarmCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteAlarmCommand extends $Command<DeleteAlarmCommandInput, DeleteAlarmCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: DeleteAlarmCommandInput;
-    constructor(input: DeleteAlarmCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAlarmCommandInput, DeleteAlarmCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteAutoSnapshotCommand.d.ts

@@ -1,35 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { DeleteAutoSnapshotRequest, DeleteAutoSnapshotResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteAutoSnapshotCommandInput extends DeleteAutoSnapshotRequest {
-}
-export interface DeleteAutoSnapshotCommandOutput extends DeleteAutoSnapshotResult, __MetadataBearer {
-}
-/**
- * <p>Deletes an automatic snapshot of 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, DeleteAutoSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteAutoSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteAutoSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteAutoSnapshotCommandInput} for command's `input` shape.
- * @see {@link DeleteAutoSnapshotCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteAutoSnapshotCommand extends $Command<DeleteAutoSnapshotCommandInput, DeleteAutoSnapshotCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: DeleteAutoSnapshotCommandInput;
-    constructor(input: DeleteAutoSnapshotCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAutoSnapshotCommandInput, DeleteAutoSnapshotCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteBucketAccessKeyCommand.d.ts

@@ -1,40 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { DeleteBucketAccessKeyRequest, DeleteBucketAccessKeyResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteBucketAccessKeyCommandInput extends DeleteBucketAccessKeyRequest {
-}
-export interface DeleteBucketAccessKeyCommandOutput extends DeleteBucketAccessKeyResult, __MetadataBearer {
-}
-/**
- * <p>Deletes an access key for the specified Amazon Lightsail bucket.</p>
- *
- *          <p>We recommend that you delete an access key if the secret access key is compromised.</p>
- *
- *          <p>For more information about access keys, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-creating-bucket-access-keys">Creating access keys for a bucket in Amazon Lightsail</a> in the
- *         <i>Amazon Lightsail Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteBucketAccessKeyCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteBucketAccessKeyCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteBucketAccessKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteBucketAccessKeyCommandInput} for command's `input` shape.
- * @see {@link DeleteBucketAccessKeyCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteBucketAccessKeyCommand extends $Command<DeleteBucketAccessKeyCommandInput, DeleteBucketAccessKeyCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: DeleteBucketAccessKeyCommandInput;
-    constructor(input: DeleteBucketAccessKeyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBucketAccessKeyCommandInput, DeleteBucketAccessKeyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteBucketCommand.d.ts

@@ -1,40 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { DeleteBucketRequest, DeleteBucketResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteBucketCommandInput extends DeleteBucketRequest {
-}
-export interface DeleteBucketCommandOutput extends DeleteBucketResult, __MetadataBearer {
-}
-/**
- * <p>Deletes a Amazon Lightsail bucket.</p>
- *
- *          <note>
- *             <p>When you delete your bucket, the bucket name is released and can be reused for a new
- *         bucket in your account or another AWS account.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteBucketCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteBucketCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteBucketCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteBucketCommandInput} for command's `input` shape.
- * @see {@link DeleteBucketCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteBucketCommand extends $Command<DeleteBucketCommandInput, DeleteBucketCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: DeleteBucketCommandInput;
-    constructor(input: DeleteBucketCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBucketCommandInput, DeleteBucketCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteCertificateCommand.d.ts

@@ -1,39 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { DeleteCertificateRequest, DeleteCertificateResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteCertificateCommandInput extends DeleteCertificateRequest {
-}
-export interface DeleteCertificateCommandOutput extends DeleteCertificateResult, __MetadataBearer {
-}
-/**
- * <p>Deletes an SSL/TLS certificate for your Amazon Lightsail content delivery network (CDN)
- *       distribution.</p>
- *          <p>Certificates that are currently attached to a distribution cannot be deleted. Use the
- *         <code>DetachCertificateFromDistribution</code> action to detach a certificate from a
- *       distribution.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, DeleteCertificateCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, DeleteCertificateCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new DeleteCertificateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteCertificateCommandInput} for command's `input` shape.
- * @see {@link DeleteCertificateCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteCertificateCommand extends $Command<DeleteCertificateCommandInput, DeleteCertificateCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: DeleteCertificateCommandInput;
-    constructor(input: DeleteCertificateCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCertificateCommandInput, DeleteCertificateCommandOutput>;
-    private serialize;
-    private deserialize;
-}