@aws-sdk/client-lightsail 3.32.0 → 3.36.0

package/dist-types/ts3.4/commands/GetBucketMetricDataCommand.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 { GetBucketMetricDataRequest, GetBucketMetricDataResult } from "../models/models_0";
+export interface GetBucketMetricDataCommandInput extends GetBucketMetricDataRequest {
+}
+export interface GetBucketMetricDataCommandOutput extends GetBucketMetricDataResult, __MetadataBearer {
+}
+/**
+ * <p>Returns the data points of a specific metric for an Amazon Lightsail bucket.</p>
+ *
+ *          <p>Metrics report the utilization of a bucket. View and collect metric data regularly to
+ *       monitor the number of objects stored in a bucket (including object versions) and the storage
+ *       space used by those objects.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, GetBucketMetricDataCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetBucketMetricDataCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetBucketMetricDataCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBucketMetricDataCommandInput} for command's `input` shape.
+ * @see {@link GetBucketMetricDataCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBucketMetricDataCommand extends $Command<GetBucketMetricDataCommandInput, GetBucketMetricDataCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetBucketMetricDataCommandInput;
+    constructor(input: GetBucketMetricDataCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBucketMetricDataCommandInput, GetBucketMetricDataCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/ts3.4/commands/GetBundlesCommand.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 { GetBundlesRequest, GetBundlesResult } from "../models/models_0";
+export interface GetBundlesCommandInput extends GetBundlesRequest {
+}
+export interface GetBundlesCommandOutput extends GetBundlesResult, __MetadataBearer {
+}
+/**
+ * <p>Returns the list of bundles that are available for purchase. A bundle describes the specs
+ *       for your virtual private server (or <i>instance</i>).</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, GetBundlesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetBundlesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetBundlesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBundlesCommandInput} for command's `input` shape.
+ * @see {@link GetBundlesCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBundlesCommand extends $Command<GetBundlesCommandInput, GetBundlesCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetBundlesCommandInput;
+    constructor(input: GetBundlesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBundlesCommandInput, GetBundlesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetCertificatesCommand.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 { GetCertificatesRequest, GetCertificatesResult } from "../models/models_0";
+export interface GetCertificatesCommandInput extends GetCertificatesRequest {
+}
+export interface GetCertificatesCommandOutput extends GetCertificatesResult, __MetadataBearer {
+}
+/**
+ * <p>Returns information about one or more Amazon Lightsail SSL/TLS certificates.</p>
+ *          <note>
+ *             <p>To get a summary of a certificate, ommit <code>includeCertificateDetails</code> from
+ *         your request. The response will include only the certificate Amazon Resource Name (ARN),
+ *         certificate name, domain name, and tags.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, GetCertificatesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetCertificatesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetCertificatesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCertificatesCommandInput} for command's `input` shape.
+ * @see {@link GetCertificatesCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCertificatesCommand extends $Command<GetCertificatesCommandInput, GetCertificatesCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetCertificatesCommandInput;
+    constructor(input: GetCertificatesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCertificatesCommandInput, GetCertificatesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetCloudFormationStackRecordsCommand.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 { GetCloudFormationStackRecordsRequest, GetCloudFormationStackRecordsResult } from "../models/models_0";
+export interface GetCloudFormationStackRecordsCommandInput extends GetCloudFormationStackRecordsRequest {
+}
+export interface GetCloudFormationStackRecordsCommandOutput extends GetCloudFormationStackRecordsResult, __MetadataBearer {
+}
+/**
+ * <p>Returns the CloudFormation stack record created as a result of the <code>create cloud
+ *         formation stack</code> operation.</p>
+ *          <p>An AWS CloudFormation stack is used to create a new Amazon EC2 instance from an exported Lightsail
+ *       snapshot.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, GetCloudFormationStackRecordsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetCloudFormationStackRecordsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetCloudFormationStackRecordsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCloudFormationStackRecordsCommandInput} for command's `input` shape.
+ * @see {@link GetCloudFormationStackRecordsCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCloudFormationStackRecordsCommand extends $Command<GetCloudFormationStackRecordsCommandInput, GetCloudFormationStackRecordsCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetCloudFormationStackRecordsCommandInput;
+    constructor(input: GetCloudFormationStackRecordsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCloudFormationStackRecordsCommandInput, GetCloudFormationStackRecordsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetContactMethodsCommand.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 { GetContactMethodsRequest, GetContactMethodsResult } from "../models/models_0";
+export interface GetContactMethodsCommandInput extends GetContactMethodsRequest {
+}
+export interface GetContactMethodsCommandOutput extends GetContactMethodsResult, __MetadataBearer {
+}
+/**
+ * <p>Returns information about the configured contact methods. Specify a protocol in your
+ *       request to return information about a specific 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, GetContactMethodsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetContactMethodsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetContactMethodsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetContactMethodsCommandInput} for command's `input` shape.
+ * @see {@link GetContactMethodsCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetContactMethodsCommand extends $Command<GetContactMethodsCommandInput, GetContactMethodsCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetContactMethodsCommandInput;
+    constructor(input: GetContactMethodsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContactMethodsCommandInput, GetContactMethodsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetContainerAPIMetadataCommand.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 { GetContainerAPIMetadataRequest, GetContainerAPIMetadataResult } from "../models/models_0";
+export interface GetContainerAPIMetadataCommandInput extends GetContainerAPIMetadataRequest {
+}
+export interface GetContainerAPIMetadataCommandOutput extends GetContainerAPIMetadataResult, __MetadataBearer {
+}
+/**
+ * <p>Returns information about Amazon Lightsail containers, such as the current version of the
+ *       Lightsail Control (lightsailctl) plugin.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, GetContainerAPIMetadataCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetContainerAPIMetadataCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetContainerAPIMetadataCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetContainerAPIMetadataCommandInput} for command's `input` shape.
+ * @see {@link GetContainerAPIMetadataCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetContainerAPIMetadataCommand extends $Command<GetContainerAPIMetadataCommandInput, GetContainerAPIMetadataCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetContainerAPIMetadataCommandInput;
+    constructor(input: GetContainerAPIMetadataCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContainerAPIMetadataCommandInput, GetContainerAPIMetadataCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetContainerImagesCommand.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 { GetContainerImagesRequest, GetContainerImagesResult } from "../models/models_0";
+export interface GetContainerImagesCommandInput extends GetContainerImagesRequest {
+}
+export interface GetContainerImagesCommandOutput extends GetContainerImagesResult, __MetadataBearer {
+}
+/**
+ * <p>Returns the container images that are registered to your Amazon Lightsail container
+ *       service.</p>
+ *
+ *          <note>
+ *             <p>If you created a deployment on your Lightsail container service that uses container
+ *         images from a public registry like Docker Hub, those images are not returned as part of this
+ *         action. Those images are not registered to your Lightsail container service.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, GetContainerImagesCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetContainerImagesCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetContainerImagesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetContainerImagesCommandInput} for command's `input` shape.
+ * @see {@link GetContainerImagesCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetContainerImagesCommand extends $Command<GetContainerImagesCommandInput, GetContainerImagesCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetContainerImagesCommandInput;
+    constructor(input: GetContainerImagesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContainerImagesCommandInput, GetContainerImagesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetContainerLogCommand.d.ts

@@ -0,0 +1,45 @@
+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 { GetContainerLogRequest, GetContainerLogResult } from "../models/models_0";
+export interface GetContainerLogCommandInput extends GetContainerLogRequest {
+}
+export interface GetContainerLogCommandOutput extends GetContainerLogResult, __MetadataBearer {
+}
+/**
+ * <p>Returns the log events of a container of your Amazon Lightsail container service.</p>
+ *
+ *          <p>If your container service has more than one node (i.e., a scale greater than 1), then the
+ *       log events that are returned for the specified container are merged from all nodes on your
+ *       container service.</p>
+ *
+ *          <note>
+ *             <p>Container logs are retained for a certain amount of time. For more information, see
+ *           <a href="https://docs.aws.amazon.com/general/latest/gr/lightsail.html">Amazon Lightsail
+ *           endpoints and quotas</a> in the <i>AWS General Reference</i>.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, GetContainerLogCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetContainerLogCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetContainerLogCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetContainerLogCommandInput} for command's `input` shape.
+ * @see {@link GetContainerLogCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetContainerLogCommand extends $Command<GetContainerLogCommandInput, GetContainerLogCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetContainerLogCommandInput;
+    constructor(input: GetContainerLogCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContainerLogCommandInput, GetContainerLogCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetContainerServiceDeploymentsCommand.d.ts

@@ -0,0 +1,47 @@
+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 { GetContainerServiceDeploymentsRequest, GetContainerServiceDeploymentsResult } from "../models/models_0";
+export interface GetContainerServiceDeploymentsCommandInput extends GetContainerServiceDeploymentsRequest {
+}
+export interface GetContainerServiceDeploymentsCommandOutput extends GetContainerServiceDeploymentsResult, __MetadataBearer {
+}
+/**
+ * <p>Returns the deployments for your Amazon Lightsail container service</p>
+ *
+ *          <p>A deployment specifies the settings, such as the ports and launch command, of containers
+ *       that are deployed to your container service.</p>
+ *
+ *          <p>The deployments are ordered by version in ascending order. The newest version is listed at
+ *       the top of the response.</p>
+ *
+ *          <note>
+ *             <p>A set number of deployments are kept before the oldest one is replaced with the newest
+ *         one. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/lightsail.html">Amazon Lightsail
+ *           endpoints and quotas</a> in the <i>AWS General Reference</i>.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, GetContainerServiceDeploymentsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetContainerServiceDeploymentsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetContainerServiceDeploymentsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetContainerServiceDeploymentsCommandInput} for command's `input` shape.
+ * @see {@link GetContainerServiceDeploymentsCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetContainerServiceDeploymentsCommand extends $Command<GetContainerServiceDeploymentsCommandInput, GetContainerServiceDeploymentsCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetContainerServiceDeploymentsCommandInput;
+    constructor(input: GetContainerServiceDeploymentsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContainerServiceDeploymentsCommandInput, GetContainerServiceDeploymentsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetContainerServiceMetricDataCommand.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 { GetContainerServiceMetricDataRequest, GetContainerServiceMetricDataResult } from "../models/models_0";
+export interface GetContainerServiceMetricDataCommandInput extends GetContainerServiceMetricDataRequest {
+}
+export interface GetContainerServiceMetricDataCommandOutput extends GetContainerServiceMetricDataResult, __MetadataBearer {
+}
+/**
+ * <p>Returns the data points of a specific metric of your Amazon Lightsail container
+ *       service.</p>
+ *
+ *          <p>Metrics report the utilization of your resources. Monitor and collect metric data
+ *       regularly to maintain the reliability, availability, and performance of your resources.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, GetContainerServiceMetricDataCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetContainerServiceMetricDataCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetContainerServiceMetricDataCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetContainerServiceMetricDataCommandInput} for command's `input` shape.
+ * @see {@link GetContainerServiceMetricDataCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetContainerServiceMetricDataCommand extends $Command<GetContainerServiceMetricDataCommandInput, GetContainerServiceMetricDataCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetContainerServiceMetricDataCommandInput;
+    constructor(input: GetContainerServiceMetricDataCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContainerServiceMetricDataCommandInput, GetContainerServiceMetricDataCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetContainerServicePowersCommand.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 { GetContainerServicePowersRequest, GetContainerServicePowersResult } from "../models/models_0";
+export interface GetContainerServicePowersCommandInput extends GetContainerServicePowersRequest {
+}
+export interface GetContainerServicePowersCommandOutput extends GetContainerServicePowersResult, __MetadataBearer {
+}
+/**
+ * <p>Returns the list of powers that can be specified for your Amazon Lightsail container
+ *       services.</p>
+ *
+ *          <p>The power specifies the amount of memory, the number of vCPUs, and the base price of the
+ *       container service.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, GetContainerServicePowersCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetContainerServicePowersCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetContainerServicePowersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetContainerServicePowersCommandInput} for command's `input` shape.
+ * @see {@link GetContainerServicePowersCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetContainerServicePowersCommand extends $Command<GetContainerServicePowersCommandInput, GetContainerServicePowersCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetContainerServicePowersCommandInput;
+    constructor(input: GetContainerServicePowersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContainerServicePowersCommandInput, GetContainerServicePowersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

package/dist-types/ts3.4/commands/GetDiskSnapshotsCommand.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 { GetDiskSnapshotsRequest, GetDiskSnapshotsResult } from "../models/models_0";
+export interface GetDiskSnapshotsCommandInput extends GetDiskSnapshotsRequest {
+}
+export interface GetDiskSnapshotsCommandOutput extends GetDiskSnapshotsResult, __MetadataBearer {
+}
+/**
+ * <p>Returns information about all block storage disk snapshots in your AWS account and
+ *       region.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LightsailClient, GetDiskSnapshotsCommand } from "@aws-sdk/client-lightsail"; // ES Modules import
+ * // const { LightsailClient, GetDiskSnapshotsCommand } = require("@aws-sdk/client-lightsail"); // CommonJS import
+ * const client = new LightsailClient(config);
+ * const command = new GetDiskSnapshotsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDiskSnapshotsCommandInput} for command's `input` shape.
+ * @see {@link GetDiskSnapshotsCommandOutput} for command's `response` shape.
+ * @see {@link LightsailClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDiskSnapshotsCommand extends $Command<GetDiskSnapshotsCommandInput, GetDiskSnapshotsCommandOutput, LightsailClientResolvedConfig> {
+    readonly input: GetDiskSnapshotsCommandInput;
+    constructor(input: GetDiskSnapshotsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LightsailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDiskSnapshotsCommandInput, GetDiskSnapshotsCommandOutput>;
+    private serialize;
+    private deserialize;
+}