@aws-sdk/client-lightsail 3.34.0 → 3.35.0

package/dist-types/ts3.4/commands/DeleteContactMethodCommand.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 { DeleteContactMethodRequest, DeleteContactMethodResult } from "../models/models_0";
+export interface DeleteContactMethodCommandInput extends DeleteContactMethodRequest {
+}
+export interface DeleteContactMethodCommandOutput extends DeleteContactMethodResult, __MetadataBearer {
+}
+/**
+ * <p>Deletes a contact method.</p>
+ *          <p>A contact method is used to send you notifications about your Amazon Lightsail resources.
+ *       You can add one email address and one mobile phone number contact method in each AWS Region.
+ *       However, SMS text messaging is not supported in some AWS Regions, and SMS text messages
+ *       cannot be sent to some countries/regions. For more information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-notifications">Notifications in Amazon Lightsail</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, DeleteContactMethodCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DeleteContactMethodCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DeleteContactMethodCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteContactMethodCommandInput} for command's `input` shape.
+ * @see {@link DeleteContactMethodCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteContactMethodCommand extends $Command<DeleteContactMethodCommandInput, DeleteContactMethodCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DeleteContactMethodCommandInput;
+    constructor(input: DeleteContactMethodCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteContactMethodCommandInput, DeleteContactMethodCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DeleteContainerImageCommand.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 { DeleteContainerImageRequest, DeleteContainerImageResult } from "../models/models_0";
+export interface DeleteContainerImageCommandInput extends DeleteContainerImageRequest {
+}
+export interface DeleteContainerImageCommandOutput extends DeleteContainerImageResult, __MetadataBearer {
+}
+/**
+ * <p>Deletes a container image that is registered to your Amazon Lightsail container
+ *       service.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, DeleteContainerImageCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DeleteContainerImageCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DeleteContainerImageCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteContainerImageCommandInput} for command's `input` shape.
+ * @see {@link DeleteContainerImageCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteContainerImageCommand extends $Command<DeleteContainerImageCommandInput, DeleteContainerImageCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DeleteContainerImageCommandInput;
+    constructor(input: DeleteContainerImageCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteContainerImageCommandInput, DeleteContainerImageCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/ts3.4/commands/DeleteDiskCommand.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 { DeleteDiskRequest, DeleteDiskResult } from "../models/models_0";
+export interface DeleteDiskCommandInput extends DeleteDiskRequest {
+}
+export interface DeleteDiskCommandOutput extends DeleteDiskResult, __MetadataBearer {
+}
+/**
+ * <p>Deletes the specified block storage disk. The disk must be in the <code>available</code>
+ *       state (not attached to a Lightsail instance).</p>
+ *          <note>
+ *             <p>The disk may remain in the <code>deleting</code> state for several minutes.</p>
+ *          </note>
+ *          <p>The <code>delete 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, DeleteDiskCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DeleteDiskCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DeleteDiskCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDiskCommandInput} for command's `input` shape.
+ * @see {@link DeleteDiskCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteDiskCommand extends $Command<DeleteDiskCommandInput, DeleteDiskCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DeleteDiskCommandInput;
+    constructor(input: DeleteDiskCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDiskCommandInput, DeleteDiskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DeleteDiskSnapshotCommand.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 { DeleteDiskSnapshotRequest, DeleteDiskSnapshotResult } from "../models/models_0";
+export interface DeleteDiskSnapshotCommandInput extends DeleteDiskSnapshotRequest {
+}
+export interface DeleteDiskSnapshotCommandOutput extends DeleteDiskSnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>Deletes the specified disk snapshot.</p>
+ *          <p>When you make periodic snapshots of a disk, the snapshots are incremental, and only the
+ *       blocks on the device that have changed since your last snapshot are saved in the new snapshot.
+ *       When you delete a snapshot, only the data not needed for any other snapshot is removed. So
+ *       regardless of which prior snapshots have been deleted, all active snapshots will have access
+ *       to all the information needed to restore the disk.</p>
+ *          <p>The <code>delete disk snapshot</code> operation supports tag-based access control via
+ *       resource tags applied to the resource identified by <code>disk 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, DeleteDiskSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DeleteDiskSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DeleteDiskSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDiskSnapshotCommandInput} for command's `input` shape.
+ * @see {@link DeleteDiskSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteDiskSnapshotCommand extends $Command<DeleteDiskSnapshotCommandInput, DeleteDiskSnapshotCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DeleteDiskSnapshotCommandInput;
+    constructor(input: DeleteDiskSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDiskSnapshotCommandInput, DeleteDiskSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DeleteDistributionCommand.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 { DeleteDistributionRequest, DeleteDistributionResult } from "../models/models_0";
+export interface DeleteDistributionCommandInput extends DeleteDistributionRequest {
+}
+export interface DeleteDistributionCommandOutput extends DeleteDistributionResult, __MetadataBearer {
+}
+/**
+ * <p>Deletes your Amazon Lightsail content delivery network (CDN) distribution.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, DeleteDistributionCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DeleteDistributionCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DeleteDistributionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDistributionCommandInput} for command's `input` shape.
+ * @see {@link DeleteDistributionCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteDistributionCommand extends $Command<DeleteDistributionCommandInput, DeleteDistributionCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DeleteDistributionCommandInput;
+    constructor(input: DeleteDistributionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDistributionCommandInput, DeleteDistributionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DeleteDomainCommand.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 { DeleteDomainRequest, DeleteDomainResult } from "../models/models_0";
+export interface DeleteDomainCommandInput extends DeleteDomainRequest {
+}
+export interface DeleteDomainCommandOutput extends DeleteDomainResult, __MetadataBearer {
+}
+/**
+ * <p>Deletes the specified domain recordset and all of its domain records.</p>
+ *          <p>The <code>delete domain</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, DeleteDomainCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DeleteDomainCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DeleteDomainCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDomainCommandInput} for command's `input` shape.
+ * @see {@link DeleteDomainCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteDomainCommand extends $Command<DeleteDomainCommandInput, DeleteDomainCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DeleteDomainCommandInput;
+    constructor(input: DeleteDomainCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDomainCommandInput, DeleteDomainCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/ts3.4/commands/DeleteInstanceSnapshotCommand.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 { DeleteInstanceSnapshotRequest, DeleteInstanceSnapshotResult } from "../models/models_0";
+export interface DeleteInstanceSnapshotCommandInput extends DeleteInstanceSnapshotRequest {
+}
+export interface DeleteInstanceSnapshotCommandOutput extends DeleteInstanceSnapshotResult, __MetadataBearer {
+}
+/**
+ * <p>Deletes a specific snapshot of a virtual private server (or
+ *       <i>instance</i>).</p>
+ *          <p>The <code>delete instance snapshot</code> operation supports tag-based access control via
+ *       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, DeleteInstanceSnapshotCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DeleteInstanceSnapshotCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DeleteInstanceSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteInstanceSnapshotCommandInput} for command's `input` shape.
+ * @see {@link DeleteInstanceSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteInstanceSnapshotCommand extends $Command<DeleteInstanceSnapshotCommandInput, DeleteInstanceSnapshotCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DeleteInstanceSnapshotCommandInput;
+    constructor(input: DeleteInstanceSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteInstanceSnapshotCommandInput, DeleteInstanceSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DeleteKeyPairCommand.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 { DeleteKeyPairRequest, DeleteKeyPairResult } from "../models/models_0";
+export interface DeleteKeyPairCommandInput extends DeleteKeyPairRequest {
+}
+export interface DeleteKeyPairCommandOutput extends DeleteKeyPairResult, __MetadataBearer {
+}
+/**
+ * <p>Deletes a specific SSH key pair.</p>
+ *          <p>The <code>delete key pair</code> operation supports tag-based access control via resource
+ *       tags applied to the resource identified by <code>key pair 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, DeleteKeyPairCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DeleteKeyPairCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DeleteKeyPairCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteKeyPairCommandInput} for command's `input` shape.
+ * @see {@link DeleteKeyPairCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteKeyPairCommand extends $Command<DeleteKeyPairCommandInput, DeleteKeyPairCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DeleteKeyPairCommandInput;
+    constructor(input: DeleteKeyPairCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteKeyPairCommandInput, DeleteKeyPairCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DeleteKnownHostKeysCommand.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 { DeleteKnownHostKeysRequest, DeleteKnownHostKeysResult } from "../models/models_0";
+export interface DeleteKnownHostKeysCommandInput extends DeleteKnownHostKeysRequest {
+}
+export interface DeleteKnownHostKeysCommandOutput extends DeleteKnownHostKeysResult, __MetadataBearer {
+}
+/**
+ * <p>Deletes the known host key or certificate used by the Amazon Lightsail browser-based SSH or
+ *       RDP clients to authenticate an instance. This operation enables the Lightsail browser-based
+ *       SSH or RDP clients to connect to the instance after a host key mismatch.</p>
+ *          <important>
+ *             <p>Perform this operation only if you were expecting the host key or certificate mismatch
+ *         or if you are familiar with the new host key or certificate on the instance. For more
+ *         information, see <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-troubleshooting-browser-based-ssh-rdp-client-connection">Troubleshooting connection issues when using the Amazon Lightsail browser-based SSH or RDP
+ *           client</a>.</p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, DeleteKnownHostKeysCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DeleteKnownHostKeysCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DeleteKnownHostKeysCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteKnownHostKeysCommandInput} for command's `input` shape.
+ * @see {@link DeleteKnownHostKeysCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteKnownHostKeysCommand extends $Command<DeleteKnownHostKeysCommandInput, DeleteKnownHostKeysCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DeleteKnownHostKeysCommandInput;
+    constructor(input: DeleteKnownHostKeysCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteKnownHostKeysCommandInput, DeleteKnownHostKeysCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DeleteLoadBalancerCommand.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 { DeleteLoadBalancerRequest, DeleteLoadBalancerResult } from "../models/models_0";
+export interface DeleteLoadBalancerCommandInput extends DeleteLoadBalancerRequest {
+}
+export interface DeleteLoadBalancerCommandOutput extends DeleteLoadBalancerResult, __MetadataBearer {
+}
+/**
+ * <p>Deletes a Lightsail load balancer and all its associated SSL/TLS certificates. Once the
+ *       load balancer is deleted, you will need to create a new load balancer, create a new
+ *       certificate, and verify domain ownership again.</p>
+ *          <p>The <code>delete 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, DeleteLoadBalancerCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DeleteLoadBalancerCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DeleteLoadBalancerCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteLoadBalancerCommandInput} for command's `input` shape.
+ * @see {@link DeleteLoadBalancerCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteLoadBalancerCommand extends $Command<DeleteLoadBalancerCommandInput, DeleteLoadBalancerCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DeleteLoadBalancerCommandInput;
+    constructor(input: DeleteLoadBalancerCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLoadBalancerCommandInput, DeleteLoadBalancerCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DeleteLoadBalancerTlsCertificateCommand.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 { DeleteLoadBalancerTlsCertificateRequest, DeleteLoadBalancerTlsCertificateResult } from "../models/models_0";
+export interface DeleteLoadBalancerTlsCertificateCommandInput extends DeleteLoadBalancerTlsCertificateRequest {
+}
+export interface DeleteLoadBalancerTlsCertificateCommandOutput extends DeleteLoadBalancerTlsCertificateResult, __MetadataBearer {
+}
+/**
+ * <p>Deletes an SSL/TLS certificate associated with a Lightsail load balancer.</p>
+ *          <p>The <code>DeleteLoadBalancerTlsCertificate</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, DeleteLoadBalancerTlsCertificateCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, DeleteLoadBalancerTlsCertificateCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new DeleteLoadBalancerTlsCertificateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteLoadBalancerTlsCertificateCommandInput} for command's `input` shape.
+ * @see {@link DeleteLoadBalancerTlsCertificateCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteLoadBalancerTlsCertificateCommand extends $Command<DeleteLoadBalancerTlsCertificateCommandInput, DeleteLoadBalancerTlsCertificateCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: DeleteLoadBalancerTlsCertificateCommandInput;
+    constructor(input: DeleteLoadBalancerTlsCertificateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLoadBalancerTlsCertificateCommandInput, DeleteLoadBalancerTlsCertificateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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