@aws-sdk/client-lightsail 3.32.0 → 3.36.0

package/dist-types/commands/UpdateContainerServiceCommand.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 { UpdateContainerServiceRequest, UpdateContainerServiceResult } from "../models/models_1";
+export interface UpdateContainerServiceCommandInput extends UpdateContainerServiceRequest {
+}
+export interface UpdateContainerServiceCommandOutput extends UpdateContainerServiceResult, __MetadataBearer {
+}
+/**
+ * <p>Updates the configuration of your Amazon Lightsail container service, such as its power,
+ *       scale, and public domain names.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, UpdateContainerServiceCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, UpdateContainerServiceCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new UpdateContainerServiceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateContainerServiceCommandInput} for command's `input` shape.
+ * @see {@link UpdateContainerServiceCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateContainerServiceCommand extends $Command<UpdateContainerServiceCommandInput, UpdateContainerServiceCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: UpdateContainerServiceCommandInput;
+    constructor(input: UpdateContainerServiceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateContainerServiceCommandInput, UpdateContainerServiceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,44 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { UpdateDistributionBundleRequest, UpdateDistributionBundleResult } from "../models/models_1";
+export interface UpdateDistributionBundleCommandInput extends UpdateDistributionBundleRequest {
+}
+export interface UpdateDistributionBundleCommandOutput extends UpdateDistributionBundleResult, __MetadataBearer {
+}
+/**
+ * <p>Updates the bundle of your Amazon Lightsail content delivery network (CDN)
+ *       distribution.</p>
+ *          <p>A distribution bundle specifies the monthly network transfer quota and monthly cost of
+ *       your dsitribution.</p>
+ *          <p>Update your distribution's bundle if your distribution is going over its monthly network
+ *       transfer quota and is incurring an overage fee.</p>
+ *          <p>You can update your distribution's bundle only one time within your monthly AWS billing
+ *       cycle. To determine if you can update your distribution's bundle, use the
+ *         <code>GetDistributions</code> action. The <code>ableToUpdateBundle</code> parameter in the
+ *       result will indicate whether you can currently update your distribution's bundle.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, UpdateDistributionBundleCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, UpdateDistributionBundleCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new UpdateDistributionBundleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateDistributionBundleCommandInput} for command's `input` shape.
+ * @see {@link UpdateDistributionBundleCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateDistributionBundleCommand extends $Command<UpdateDistributionBundleCommandInput, UpdateDistributionBundleCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: UpdateDistributionBundleCommandInput;
+    constructor(input: UpdateDistributionBundleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDistributionBundleCommandInput, UpdateDistributionBundleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/UpdateDomainEntryCommand.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 { UpdateDomainEntryRequest, UpdateDomainEntryResult } from "../models/models_1";
+export interface UpdateDomainEntryCommandInput extends UpdateDomainEntryRequest {
+}
+export interface UpdateDomainEntryCommandOutput extends UpdateDomainEntryResult, __MetadataBearer {
+}
+/**
+ * <p>Updates a domain recordset after it is created.</p>
+ *          <p>The <code>update 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, UpdateDomainEntryCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, UpdateDomainEntryCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new UpdateDomainEntryCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateDomainEntryCommandInput} for command's `input` shape.
+ * @see {@link UpdateDomainEntryCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateDomainEntryCommand extends $Command<UpdateDomainEntryCommandInput, UpdateDomainEntryCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: UpdateDomainEntryCommandInput;
+    constructor(input: UpdateDomainEntryCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDomainEntryCommandInput, UpdateDomainEntryCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateLoadBalancerAttributeCommand.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 { UpdateLoadBalancerAttributeRequest, UpdateLoadBalancerAttributeResult } from "../models/models_1";
+export interface UpdateLoadBalancerAttributeCommandInput extends UpdateLoadBalancerAttributeRequest {
+}
+export interface UpdateLoadBalancerAttributeCommandOutput extends UpdateLoadBalancerAttributeResult, __MetadataBearer {
+}
+/**
+ * <p>Updates the specified attribute for a load balancer. You can only update one attribute at
+ *       a time.</p>
+ *          <p>The <code>update load balancer attribute</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, UpdateLoadBalancerAttributeCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, UpdateLoadBalancerAttributeCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new UpdateLoadBalancerAttributeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateLoadBalancerAttributeCommandInput} for command's `input` shape.
+ * @see {@link UpdateLoadBalancerAttributeCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateLoadBalancerAttributeCommand extends $Command<UpdateLoadBalancerAttributeCommandInput, UpdateLoadBalancerAttributeCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: UpdateLoadBalancerAttributeCommandInput;
+    constructor(input: UpdateLoadBalancerAttributeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateLoadBalancerAttributeCommandInput, UpdateLoadBalancerAttributeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateRelationalDatabaseCommand.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 { UpdateRelationalDatabaseRequest, UpdateRelationalDatabaseResult } from "../models/models_1";
+export interface UpdateRelationalDatabaseCommandInput extends UpdateRelationalDatabaseRequest {
+}
+export interface UpdateRelationalDatabaseCommandOutput extends UpdateRelationalDatabaseResult, __MetadataBearer {
+}
+/**
+ * <p>Allows the update of one or more attributes of a database in Amazon Lightsail.</p>
+ *          <p>Updates are applied immediately, or in cases where the updates could result in an outage,
+ *       are applied during the database's predefined maintenance window.</p>
+ *          <p>The <code>update 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, UpdateRelationalDatabaseCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, UpdateRelationalDatabaseCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new UpdateRelationalDatabaseCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateRelationalDatabaseCommandInput} for command's `input` shape.
+ * @see {@link UpdateRelationalDatabaseCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateRelationalDatabaseCommand extends $Command<UpdateRelationalDatabaseCommandInput, UpdateRelationalDatabaseCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: UpdateRelationalDatabaseCommandInput;
+    constructor(input: UpdateRelationalDatabaseCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateRelationalDatabaseCommandInput, UpdateRelationalDatabaseCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,44 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LightsailClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LightsailClient";
+import { UpdateRelationalDatabaseParametersRequest, UpdateRelationalDatabaseParametersResult } from "../models/models_1";
+export interface UpdateRelationalDatabaseParametersCommandInput extends UpdateRelationalDatabaseParametersRequest {
+}
+export interface UpdateRelationalDatabaseParametersCommandOutput extends UpdateRelationalDatabaseParametersResult, __MetadataBearer {
+}
+/**
+ * <p>Allows the update of one or more parameters of a database in Amazon Lightsail.</p>
+ *          <p>Parameter updates don't cause outages; therefore, their application is not subject to the
+ *       preferred maintenance window. However, there are two ways in which parameter updates are
+ *       applied: <code>dynamic</code> or <code>pending-reboot</code>. Parameters marked with a
+ *         <code>dynamic</code> apply type are applied immediately. Parameters marked with a
+ *         <code>pending-reboot</code> apply type are applied only after the database is rebooted using
+ *       the <code>reboot relational database</code> operation.</p>
+ *          <p>The <code>update relational database parameters</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, UpdateRelationalDatabaseParametersCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, UpdateRelationalDatabaseParametersCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new UpdateRelationalDatabaseParametersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateRelationalDatabaseParametersCommandInput} for command's `input` shape.
+ * @see {@link UpdateRelationalDatabaseParametersCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateRelationalDatabaseParametersCommand extends $Command<UpdateRelationalDatabaseParametersCommandInput, UpdateRelationalDatabaseParametersCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: UpdateRelationalDatabaseParametersCommandInput;
+    constructor(input: UpdateRelationalDatabaseParametersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateRelationalDatabaseParametersCommandInput, UpdateRelationalDatabaseParametersCommandOutput>;
+    private serialize;
+    private deserialize;
+}