@aws-sdk/client-lightsail 3.34.0 → 3.35.0

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

@@ -1,35 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { ReleaseStaticIpRequest, ReleaseStaticIpResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ReleaseStaticIpCommandInput extends ReleaseStaticIpRequest {
-}
-export interface ReleaseStaticIpCommandOutput extends ReleaseStaticIpResult, __MetadataBearer {
-}
-/**
- * <p>Deletes a specific static IP from your account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, ReleaseStaticIpCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, ReleaseStaticIpCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new ReleaseStaticIpCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ReleaseStaticIpCommandInput} for command's `input` shape.
- * @see {@link ReleaseStaticIpCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ReleaseStaticIpCommand extends $Command<ReleaseStaticIpCommandInput, ReleaseStaticIpCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: ReleaseStaticIpCommandInput;
-    constructor(input: ReleaseStaticIpCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReleaseStaticIpCommandInput, ReleaseStaticIpCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,38 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { ResetDistributionCacheRequest, ResetDistributionCacheResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ResetDistributionCacheCommandInput extends ResetDistributionCacheRequest {
-}
-export interface ResetDistributionCacheCommandOutput extends ResetDistributionCacheResult, __MetadataBearer {
-}
-/**
- * <p>Deletes currently cached content from your Amazon Lightsail content delivery network (CDN)
- *       distribution.</p>
- *          <p>After resetting the cache, the next time a content request is made, your distribution
- *       pulls, serves, and caches it from the origin.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, ResetDistributionCacheCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, ResetDistributionCacheCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new ResetDistributionCacheCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ResetDistributionCacheCommandInput} for command's `input` shape.
- * @see {@link ResetDistributionCacheCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ResetDistributionCacheCommand extends $Command<ResetDistributionCacheCommandInput, ResetDistributionCacheCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: ResetDistributionCacheCommandInput;
-    constructor(input: ResetDistributionCacheCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetDistributionCacheCommandInput, ResetDistributionCacheCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,47 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { SendContactMethodVerificationRequest, SendContactMethodVerificationResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface SendContactMethodVerificationCommandInput extends SendContactMethodVerificationRequest {
-}
-export interface SendContactMethodVerificationCommandOutput extends SendContactMethodVerificationResult, __MetadataBearer {
-}
-/**
- * <p>Sends a verification request to an email contact method to ensure it's owned by the
- *       requester. SMS contact methods don't need to be verified.</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>
- *          <p>A verification request is sent to the contact method when you initially create it. Use
- *       this action to send another verification request if a previous verification request was
- *       deleted, or has expired.</p>
- *          <important>
- *             <p>Notifications are not sent to an email contact method until after it is verified, and
- *         confirmed as valid.</p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, SendContactMethodVerificationCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, SendContactMethodVerificationCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new SendContactMethodVerificationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SendContactMethodVerificationCommandInput} for command's `input` shape.
- * @see {@link SendContactMethodVerificationCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class SendContactMethodVerificationCommand extends $Command<SendContactMethodVerificationCommandInput, SendContactMethodVerificationCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: SendContactMethodVerificationCommandInput;
-    constructor(input: SendContactMethodVerificationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendContactMethodVerificationCommandInput, SendContactMethodVerificationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,39 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { SetIpAddressTypeRequest, SetIpAddressTypeResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface SetIpAddressTypeCommandInput extends SetIpAddressTypeRequest {
-}
-export interface SetIpAddressTypeCommandOutput extends SetIpAddressTypeResult, __MetadataBearer {
-}
-/**
- * <p>Sets the IP address type for an Amazon Lightsail resource.</p>
- *
- *          <p>Use this action to enable dual-stack for a resource, which enables IPv4 and IPv6 for the
- *       specified resource. Alternately, you can use this action to disable dual-stack, and enable
- *       IPv4 only.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, SetIpAddressTypeCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, SetIpAddressTypeCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new SetIpAddressTypeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetIpAddressTypeCommandInput} for command's `input` shape.
- * @see {@link SetIpAddressTypeCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class SetIpAddressTypeCommand extends $Command<SetIpAddressTypeCommandInput, SetIpAddressTypeCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: SetIpAddressTypeCommandInput;
-    constructor(input: SetIpAddressTypeCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetIpAddressTypeCommandInput, SetIpAddressTypeCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,39 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { SetResourceAccessForBucketRequest, SetResourceAccessForBucketResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface SetResourceAccessForBucketCommandInput extends SetResourceAccessForBucketRequest {
-}
-export interface SetResourceAccessForBucketCommandOutput extends SetResourceAccessForBucketResult, __MetadataBearer {
-}
-/**
- * <p>Sets the Amazon Lightsail resources that can access the specified Lightsail
- *       bucket.</p>
- *
- *          <p>Lightsail buckets currently support setting access for Lightsail instances in the same
- *       AWS Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, SetResourceAccessForBucketCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, SetResourceAccessForBucketCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new SetResourceAccessForBucketCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetResourceAccessForBucketCommandInput} for command's `input` shape.
- * @see {@link SetResourceAccessForBucketCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class SetResourceAccessForBucketCommand extends $Command<SetResourceAccessForBucketCommandInput, SetResourceAccessForBucketCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: SetResourceAccessForBucketCommandInput;
-    constructor(input: SetResourceAccessForBucketCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetResourceAccessForBucketCommandInput, SetResourceAccessForBucketCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,44 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { StartInstanceRequest, StartInstanceResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StartInstanceCommandInput extends StartInstanceRequest {
-}
-export interface StartInstanceCommandOutput extends StartInstanceResult, __MetadataBearer {
-}
-/**
- * <p>Starts a specific Amazon Lightsail instance from a stopped state. To restart an instance,
- *       use the <code>reboot instance</code> operation.</p>
- *          <note>
- *             <p>When you start a stopped instance, Lightsail assigns a new public IP address to the
- *         instance. To use the same IP address after stopping and starting an instance, create a
- *         static IP address and attach it to the instance. For more information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/lightsail-create-static-ip">Amazon Lightsail Developer Guide</a>.</p>
- *          </note>
- *          <p>The <code>start 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, StartInstanceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, StartInstanceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new StartInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartInstanceCommandInput} for command's `input` shape.
- * @see {@link StartInstanceCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StartInstanceCommand extends $Command<StartInstanceCommandInput, StartInstanceCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: StartInstanceCommandInput;
-    constructor(input: StartInstanceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartInstanceCommandInput, StartInstanceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,39 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { StartRelationalDatabaseRequest, StartRelationalDatabaseResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StartRelationalDatabaseCommandInput extends StartRelationalDatabaseRequest {
-}
-export interface StartRelationalDatabaseCommandOutput extends StartRelationalDatabaseResult, __MetadataBearer {
-}
-/**
- * <p>Starts a specific database from a stopped state in Amazon Lightsail. To restart a database,
- *       use the <code>reboot relational database</code> operation.</p>
- *          <p>The <code>start 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, StartRelationalDatabaseCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, StartRelationalDatabaseCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new StartRelationalDatabaseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartRelationalDatabaseCommandInput} for command's `input` shape.
- * @see {@link StartRelationalDatabaseCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StartRelationalDatabaseCommand extends $Command<StartRelationalDatabaseCommandInput, StartRelationalDatabaseCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: StartRelationalDatabaseCommandInput;
-    constructor(input: StartRelationalDatabaseCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartRelationalDatabaseCommandInput, StartRelationalDatabaseCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,43 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { StopInstanceRequest, StopInstanceResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StopInstanceCommandInput extends StopInstanceRequest {
-}
-export interface StopInstanceCommandOutput extends StopInstanceResult, __MetadataBearer {
-}
-/**
- * <p>Stops a specific Amazon Lightsail instance that is currently running.</p>
- *          <note>
- *             <p>When you start a stopped instance, Lightsail assigns a new public IP address to the
- *         instance. To use the same IP address after stopping and starting an instance, create a
- *         static IP address and attach it to the instance. For more information, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/lightsail-create-static-ip">Amazon Lightsail Developer Guide</a>.</p>
- *          </note>
- *          <p>The <code>stop 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, StopInstanceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, StopInstanceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new StopInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopInstanceCommandInput} for command's `input` shape.
- * @see {@link StopInstanceCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StopInstanceCommand extends $Command<StopInstanceCommandInput, StopInstanceCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: StopInstanceCommandInput;
-    constructor(input: StopInstanceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopInstanceCommandInput, StopInstanceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,38 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { StopRelationalDatabaseRequest, StopRelationalDatabaseResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StopRelationalDatabaseCommandInput extends StopRelationalDatabaseRequest {
-}
-export interface StopRelationalDatabaseCommandOutput extends StopRelationalDatabaseResult, __MetadataBearer {
-}
-/**
- * <p>Stops a specific database that is currently running in Amazon Lightsail.</p>
- *          <p>The <code>stop 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, StopRelationalDatabaseCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, StopRelationalDatabaseCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new StopRelationalDatabaseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopRelationalDatabaseCommandInput} for command's `input` shape.
- * @see {@link StopRelationalDatabaseCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StopRelationalDatabaseCommand extends $Command<StopRelationalDatabaseCommandInput, StopRelationalDatabaseCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: StopRelationalDatabaseCommandInput;
-    constructor(input: StopRelationalDatabaseCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopRelationalDatabaseCommandInput, StopRelationalDatabaseCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,40 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { TagResourceRequest, TagResourceResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface TagResourceCommandInput extends TagResourceRequest {
-}
-export interface TagResourceCommandOutput extends TagResourceResult, __MetadataBearer {
-}
-/**
- * <p>Adds one or more tags to the specified Amazon Lightsail resource. Each resource can have a
- *       maximum of 50 tags. Each tag consists of a key and an optional value. Tag keys must be unique
- *       per resource. For more information about tags, see the <a href="https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-tags">Amazon Lightsail Developer Guide</a>.</p>
- *          <p>The <code>tag resource</code> operation supports tag-based access control via request tags
- *       and resource tags applied to the resource identified by <code>resource 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, TagResourceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, TagResourceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: TagResourceCommandInput;
-    constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,42 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { TestAlarmRequest, TestAlarmResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface TestAlarmCommandInput extends TestAlarmRequest {
-}
-export interface TestAlarmCommandOutput extends TestAlarmResult, __MetadataBearer {
-}
-/**
- * <p>Tests an alarm by displaying a banner on the Amazon Lightsail console. If a notification
- *       trigger is configured for the specified alarm, the test also sends a notification to the
- *       notification protocol (<code>Email</code> and/or <code>SMS</code>) configured for the
- *       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, TestAlarmCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, TestAlarmCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new TestAlarmCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TestAlarmCommandInput} for command's `input` shape.
- * @see {@link TestAlarmCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class TestAlarmCommand extends $Command<TestAlarmCommandInput, TestAlarmCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: TestAlarmCommandInput;
-    constructor(input: TestAlarmCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestAlarmCommandInput, TestAlarmCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,35 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { UnpeerVpcRequest, UnpeerVpcResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UnpeerVpcCommandInput extends UnpeerVpcRequest {
-}
-export interface UnpeerVpcCommandOutput extends UnpeerVpcResult, __MetadataBearer {
-}
-/**
- * <p>Unpeers the Lightsail VPC from the user's default VPC.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, UnpeerVpcCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, UnpeerVpcCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new UnpeerVpcCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UnpeerVpcCommandInput} for command's `input` shape.
- * @see {@link UnpeerVpcCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UnpeerVpcCommand extends $Command<UnpeerVpcCommandInput, UnpeerVpcCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: UnpeerVpcCommandInput;
-    constructor(input: UnpeerVpcCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UnpeerVpcCommandInput, UnpeerVpcCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,39 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { UntagResourceRequest, UntagResourceResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UntagResourceCommandInput extends UntagResourceRequest {
-}
-export interface UntagResourceCommandOutput extends UntagResourceResult, __MetadataBearer {
-}
-/**
- * <p>Deletes the specified set of tag keys and their values from the specified Amazon Lightsail
- *       resource.</p>
- *          <p>The <code>untag resource</code> operation supports tag-based access control via request
- *       tags and resource tags applied to the resource identified by <code>resource 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, UntagResourceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, UntagResourceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: UntagResourceCommandInput;
-    constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,49 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { UpdateBucketBundleRequest, UpdateBucketBundleResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateBucketBundleCommandInput extends UpdateBucketBundleRequest {
-}
-export interface UpdateBucketBundleCommandOutput extends UpdateBucketBundleResult, __MetadataBearer {
-}
-/**
- * <p>Updates the bundle, or storage plan, of an existing Amazon Lightsail bucket.</p>
- *
- *          <p>A bucket bundle specifies the monthly cost, storage space, and data transfer quota for a
- *       bucket. You can update a bucket's bundle only one time within a monthly AWS billing cycle. To
- *       determine if you can update a bucket's bundle, use the <a>GetBuckets</a> action.
- *       The <code>ableToUpdateBundle</code> parameter in the response will indicate whether you can
- *       currently update a bucket's bundle.</p>
- *
- *          <p>Update a bucket's bundle if it's consistently going over its storage space or data
- *       transfer quota, or if a bucket's usage is consistently in the lower range of its storage space
- *       or data transfer quota. Due to the unpredictable usage fluctuations that a bucket might
- *       experience, we strongly recommend that you update a bucket's bundle only as a long-term
- *       strategy, instead of as a short-term, monthly cost-cutting measure. Choose a bucket bundle
- *       that will provide the bucket with ample storage space and data transfer for a long time to
- *       come.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, UpdateBucketBundleCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, UpdateBucketBundleCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new UpdateBucketBundleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateBucketBundleCommandInput} for command's `input` shape.
- * @see {@link UpdateBucketBundleCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateBucketBundleCommand extends $Command<UpdateBucketBundleCommandInput, UpdateBucketBundleCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: UpdateBucketBundleCommandInput;
-    constructor(input: UpdateBucketBundleCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateBucketBundleCommandInput, UpdateBucketBundleCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,38 +0,0 @@
-import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
-import { UpdateBucketRequest, UpdateBucketResult } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateBucketCommandInput extends UpdateBucketRequest {
-}
-export interface UpdateBucketCommandOutput extends UpdateBucketResult, __MetadataBearer {
-}
-/**
- * <p>Updates an existing Amazon Lightsail bucket.</p>
- *
- *          <p>Use this action to update the configuration of an existing bucket, such as versioning,
- *       public accessibility, and the AWS accounts that can access the bucket.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LightsailClient, UpdateBucketCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
- * // const { LightsailClient, UpdateBucketCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
- * const client = new LightsailClient(config);
- * const command = new UpdateBucketCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateBucketCommandInput} for command's `input` shape.
- * @see {@link UpdateBucketCommandOutput} for command's `response` shape.
- * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateBucketCommand extends $Command<UpdateBucketCommandInput, UpdateBucketCommandOutput, LightsailClientResolvedConfig> {
-    readonly input: UpdateBucketCommandInput;
-    constructor(input: UpdateBucketCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateBucketCommandInput, UpdateBucketCommandOutput>;
-    private serialize;
-    private deserialize;
-}