@aws-sdk/client-lightsail 3.321.1 → 3.326.0

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

@@ -39,6 +39,45 @@ export interface GetAlarmsCommandOutput extends GetAlarmsResult, __MetadataBeare
  * };
  * const command = new GetAlarmsCommand(input);
  * const response = await client.send(command);
+ * // { // GetAlarmsResult
+ * //   alarms: [ // AlarmsList
+ * //     { // Alarm
+ * //       name: "STRING_VALUE",
+ * //       arn: "STRING_VALUE",
+ * //       createdAt: new Date("TIMESTAMP"),
+ * //       location: { // ResourceLocation
+ * //         availabilityZone: "STRING_VALUE",
+ * //         regionName: "us-east-1" || "us-east-2" || "us-west-1" || "us-west-2" || "eu-west-1" || "eu-west-2" || "eu-west-3" || "eu-central-1" || "ca-central-1" || "ap-south-1" || "ap-southeast-1" || "ap-southeast-2" || "ap-northeast-1" || "ap-northeast-2" || "eu-north-1",
+ * //       },
+ * //       resourceType: "ContainerService" || "Instance" || "StaticIp" || "KeyPair" || "InstanceSnapshot" || "Domain" || "PeeredVpc" || "LoadBalancer" || "LoadBalancerTlsCertificate" || "Disk" || "DiskSnapshot" || "RelationalDatabase" || "RelationalDatabaseSnapshot" || "ExportSnapshotRecord" || "CloudFormationStackRecord" || "Alarm" || "ContactMethod" || "Distribution" || "Certificate" || "Bucket",
+ * //       supportCode: "STRING_VALUE",
+ * //       monitoredResourceInfo: { // MonitoredResourceInfo
+ * //         arn: "STRING_VALUE",
+ * //         name: "STRING_VALUE",
+ * //         resourceType: "ContainerService" || "Instance" || "StaticIp" || "KeyPair" || "InstanceSnapshot" || "Domain" || "PeeredVpc" || "LoadBalancer" || "LoadBalancerTlsCertificate" || "Disk" || "DiskSnapshot" || "RelationalDatabase" || "RelationalDatabaseSnapshot" || "ExportSnapshotRecord" || "CloudFormationStackRecord" || "Alarm" || "ContactMethod" || "Distribution" || "Certificate" || "Bucket",
+ * //       },
+ * //       comparisonOperator: "GreaterThanOrEqualToThreshold" || "GreaterThanThreshold" || "LessThanThreshold" || "LessThanOrEqualToThreshold",
+ * //       evaluationPeriods: Number("int"),
+ * //       period: Number("int"),
+ * //       threshold: Number("double"),
+ * //       datapointsToAlarm: Number("int"),
+ * //       treatMissingData: "breaching" || "notBreaching" || "ignore" || "missing",
+ * //       statistic: "Minimum" || "Maximum" || "Sum" || "Average" || "SampleCount",
+ * //       metricName: "CPUUtilization" || "NetworkIn" || "NetworkOut" || "StatusCheckFailed" || "StatusCheckFailed_Instance" || "StatusCheckFailed_System" || "ClientTLSNegotiationErrorCount" || "HealthyHostCount" || "UnhealthyHostCount" || "HTTPCode_LB_4XX_Count" || "HTTPCode_LB_5XX_Count" || "HTTPCode_Instance_2XX_Count" || "HTTPCode_Instance_3XX_Count" || "HTTPCode_Instance_4XX_Count" || "HTTPCode_Instance_5XX_Count" || "InstanceResponseTime" || "RejectedConnectionCount" || "RequestCount" || "DatabaseConnections" || "DiskQueueDepth" || "FreeStorageSpace" || "NetworkReceiveThroughput" || "NetworkTransmitThroughput" || "BurstCapacityTime" || "BurstCapacityPercentage",
+ * //       state: "OK" || "ALARM" || "INSUFFICIENT_DATA",
+ * //       unit: "Seconds" || "Microseconds" || "Milliseconds" || "Bytes" || "Kilobytes" || "Megabytes" || "Gigabytes" || "Terabytes" || "Bits" || "Kilobits" || "Megabits" || "Gigabits" || "Terabits" || "Percent" || "Count" || "Bytes/Second" || "Kilobytes/Second" || "Megabytes/Second" || "Gigabytes/Second" || "Terabytes/Second" || "Bits/Second" || "Kilobits/Second" || "Megabits/Second" || "Gigabits/Second" || "Terabits/Second" || "Count/Second" || "None",
+ * //       contactProtocols: [ // ContactProtocolsList
+ * //         "Email" || "SMS",
+ * //       ],
+ * //       notificationTriggers: [ // NotificationTriggerList
+ * //         "OK" || "ALARM" || "INSUFFICIENT_DATA",
+ * //       ],
+ * //       notificationEnabled: true || false,
+ * //     },
+ * //   ],
+ * //   nextPageToken: "STRING_VALUE",
+ * // };
+ *
  * ```
  *
  * @param GetAlarmsCommandInput - {@link GetAlarmsCommandInput}
@@ -73,6 +112,8 @@ export interface GetAlarmsCommandOutput extends GetAlarmsResult, __MetadataBeare
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetAlarmsCommand extends $Command<GetAlarmsCommandInput, GetAlarmsCommandOutput, LightsailClientResolvedConfig> {

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

@@ -32,6 +32,24 @@ export interface GetAutoSnapshotsCommandOutput extends GetAutoSnapshotsResult, _
  * };
  * const command = new GetAutoSnapshotsCommand(input);
  * const response = await client.send(command);
+ * // { // GetAutoSnapshotsResult
+ * //   resourceName: "STRING_VALUE",
+ * //   resourceType: "ContainerService" || "Instance" || "StaticIp" || "KeyPair" || "InstanceSnapshot" || "Domain" || "PeeredVpc" || "LoadBalancer" || "LoadBalancerTlsCertificate" || "Disk" || "DiskSnapshot" || "RelationalDatabase" || "RelationalDatabaseSnapshot" || "ExportSnapshotRecord" || "CloudFormationStackRecord" || "Alarm" || "ContactMethod" || "Distribution" || "Certificate" || "Bucket",
+ * //   autoSnapshots: [ // AutoSnapshotDetailsList
+ * //     { // AutoSnapshotDetails
+ * //       date: "STRING_VALUE",
+ * //       createdAt: new Date("TIMESTAMP"),
+ * //       status: "Success" || "Failed" || "InProgress" || "NotFound",
+ * //       fromAttachedDisks: [ // AttachedDiskList
+ * //         { // AttachedDisk
+ * //           path: "STRING_VALUE",
+ * //           sizeInGb: Number("int"),
+ * //         },
+ * //       ],
+ * //     },
+ * //   ],
+ * // };
+ *
  * ```
  *
  * @param GetAutoSnapshotsCommandInput - {@link GetAutoSnapshotsCommandInput}
@@ -66,6 +84,8 @@ export interface GetAutoSnapshotsCommandOutput extends GetAutoSnapshotsResult, _
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetAutoSnapshotsCommand extends $Command<GetAutoSnapshotsCommandInput, GetAutoSnapshotsCommandOutput, LightsailClientResolvedConfig> {

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

@@ -42,6 +42,27 @@ export interface GetBlueprintsCommandOutput extends GetBlueprintsResult, __Metad
  * };
  * const command = new GetBlueprintsCommand(input);
  * const response = await client.send(command);
+ * // { // GetBlueprintsResult
+ * //   blueprints: [ // BlueprintList
+ * //     { // Blueprint
+ * //       blueprintId: "STRING_VALUE",
+ * //       name: "STRING_VALUE",
+ * //       group: "STRING_VALUE",
+ * //       type: "os" || "app",
+ * //       description: "STRING_VALUE",
+ * //       isActive: true || false,
+ * //       minPower: Number("int"),
+ * //       version: "STRING_VALUE",
+ * //       versionCode: "STRING_VALUE",
+ * //       productUrl: "STRING_VALUE",
+ * //       licenseUrl: "STRING_VALUE",
+ * //       platform: "LINUX_UNIX" || "WINDOWS",
+ * //       appCategory: "LfR",
+ * //     },
+ * //   ],
+ * //   nextPageToken: "STRING_VALUE",
+ * // };
+ *
  * ```
  *
  * @param GetBlueprintsCommandInput - {@link GetBlueprintsCommandInput}
@@ -80,6 +101,8 @@ export interface GetBlueprintsCommandOutput extends GetBlueprintsResult, __Metad
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetBlueprintsCommand extends $Command<GetBlueprintsCommandInput, GetBlueprintsCommandOutput, LightsailClientResolvedConfig> {

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

@@ -36,6 +36,22 @@ export interface GetBucketAccessKeysCommandOutput extends GetBucketAccessKeysRes
  * };
  * const command = new GetBucketAccessKeysCommand(input);
  * const response = await client.send(command);
+ * // { // GetBucketAccessKeysResult
+ * //   accessKeys: [ // AccessKeyList
+ * //     { // AccessKey
+ * //       accessKeyId: "STRING_VALUE",
+ * //       secretAccessKey: "STRING_VALUE",
+ * //       status: "Active" || "Inactive",
+ * //       createdAt: new Date("TIMESTAMP"),
+ * //       lastUsed: { // AccessKeyLastUsed
+ * //         lastUsedDate: new Date("TIMESTAMP"),
+ * //         region: "STRING_VALUE",
+ * //         serviceName: "STRING_VALUE",
+ * //       },
+ * //     },
+ * //   ],
+ * // };
+ *
  * ```
  *
  * @param GetBucketAccessKeysCommandInput - {@link GetBucketAccessKeysCommandInput}
@@ -67,6 +83,8 @@ export interface GetBucketAccessKeysCommandOutput extends GetBucketAccessKeysRes
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetBucketAccessKeysCommand extends $Command<GetBucketAccessKeysCommandInput, GetBucketAccessKeysCommandOutput, LightsailClientResolvedConfig> {

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

@@ -35,6 +35,19 @@ export interface GetBucketBundlesCommandOutput extends GetBucketBundlesResult, _
  * };
  * const command = new GetBucketBundlesCommand(input);
  * const response = await client.send(command);
+ * // { // GetBucketBundlesResult
+ * //   bundles: [ // BucketBundleList
+ * //     { // BucketBundle
+ * //       bundleId: "STRING_VALUE",
+ * //       name: "STRING_VALUE",
+ * //       price: Number("float"),
+ * //       storagePerMonthInGb: Number("int"),
+ * //       transferPerMonthInGb: Number("int"),
+ * //       isActive: true || false,
+ * //     },
+ * //   ],
+ * // };
+ *
  * ```
  *
  * @param GetBucketBundlesCommandInput - {@link GetBucketBundlesCommandInput}
@@ -63,6 +76,8 @@ export interface GetBucketBundlesCommandOutput extends GetBucketBundlesResult, _
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetBucketBundlesCommand extends $Command<GetBucketBundlesCommandInput, GetBucketBundlesCommandOutput, LightsailClientResolvedConfig> {

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

@@ -42,6 +42,21 @@ export interface GetBucketMetricDataCommandOutput extends GetBucketMetricDataRes
  * };
  * const command = new GetBucketMetricDataCommand(input);
  * const response = await client.send(command);
+ * // { // GetBucketMetricDataResult
+ * //   metricName: "BucketSizeBytes" || "NumberOfObjects",
+ * //   metricData: [ // MetricDatapointList
+ * //     { // MetricDatapoint
+ * //       average: Number("double"),
+ * //       maximum: Number("double"),
+ * //       minimum: Number("double"),
+ * //       sampleCount: Number("double"),
+ * //       sum: Number("double"),
+ * //       timestamp: new Date("TIMESTAMP"),
+ * //       unit: "Seconds" || "Microseconds" || "Milliseconds" || "Bytes" || "Kilobytes" || "Megabytes" || "Gigabytes" || "Terabytes" || "Bits" || "Kilobits" || "Megabits" || "Gigabits" || "Terabits" || "Percent" || "Count" || "Bytes/Second" || "Kilobytes/Second" || "Megabytes/Second" || "Gigabytes/Second" || "Terabytes/Second" || "Bits/Second" || "Kilobits/Second" || "Megabits/Second" || "Gigabits/Second" || "Terabits/Second" || "Count/Second" || "None",
+ * //     },
+ * //   ],
+ * // };
+ *
  * ```
  *
  * @param GetBucketMetricDataCommandInput - {@link GetBucketMetricDataCommandInput}
@@ -73,6 +88,8 @@ export interface GetBucketMetricDataCommandOutput extends GetBucketMetricDataRes
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetBucketMetricDataCommand extends $Command<GetBucketMetricDataCommandInput, GetBucketMetricDataCommandOutput, LightsailClientResolvedConfig> {

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

@@ -37,6 +37,61 @@ export interface GetBucketsCommandOutput extends GetBucketsResult, __MetadataBea
  * };
  * const command = new GetBucketsCommand(input);
  * const response = await client.send(command);
+ * // { // GetBucketsResult
+ * //   buckets: [ // BucketList
+ * //     { // Bucket
+ * //       resourceType: "STRING_VALUE",
+ * //       accessRules: { // AccessRules
+ * //         getObject: "public" || "private",
+ * //         allowPublicOverrides: true || false,
+ * //       },
+ * //       arn: "STRING_VALUE",
+ * //       bundleId: "STRING_VALUE",
+ * //       createdAt: new Date("TIMESTAMP"),
+ * //       url: "STRING_VALUE",
+ * //       location: { // ResourceLocation
+ * //         availabilityZone: "STRING_VALUE",
+ * //         regionName: "us-east-1" || "us-east-2" || "us-west-1" || "us-west-2" || "eu-west-1" || "eu-west-2" || "eu-west-3" || "eu-central-1" || "ca-central-1" || "ap-south-1" || "ap-southeast-1" || "ap-southeast-2" || "ap-northeast-1" || "ap-northeast-2" || "eu-north-1",
+ * //       },
+ * //       name: "STRING_VALUE",
+ * //       supportCode: "STRING_VALUE",
+ * //       tags: [ // TagList
+ * //         { // Tag
+ * //           key: "STRING_VALUE",
+ * //           value: "STRING_VALUE",
+ * //         },
+ * //       ],
+ * //       objectVersioning: "STRING_VALUE",
+ * //       ableToUpdateBundle: true || false,
+ * //       readonlyAccessAccounts: [ // PartnerIdList
+ * //         "STRING_VALUE",
+ * //       ],
+ * //       resourcesReceivingAccess: [ // AccessReceiverList
+ * //         { // ResourceReceivingAccess
+ * //           name: "STRING_VALUE",
+ * //           resourceType: "STRING_VALUE",
+ * //         },
+ * //       ],
+ * //       state: { // BucketState
+ * //         code: "STRING_VALUE",
+ * //         message: "STRING_VALUE",
+ * //       },
+ * //       accessLogConfig: { // BucketAccessLogConfig
+ * //         enabled: true || false, // required
+ * //         destination: "STRING_VALUE",
+ * //         prefix: "STRING_VALUE",
+ * //       },
+ * //     },
+ * //   ],
+ * //   nextPageToken: "STRING_VALUE",
+ * //   accountLevelBpaSync: { // AccountLevelBpaSync
+ * //     status: "InSync" || "Failed" || "NeverSynced" || "Defaulted",
+ * //     lastSyncedAt: new Date("TIMESTAMP"),
+ * //     message: "DEFAULTED_FOR_SLR_MISSING" || "SYNC_ON_HOLD" || "DEFAULTED_FOR_SLR_MISSING_ON_HOLD" || "Unknown",
+ * //     bpaImpactsLightsail: true || false,
+ * //   },
+ * // };
+ *
  * ```
  *
  * @param GetBucketsCommandInput - {@link GetBucketsCommandInput}
@@ -68,6 +123,8 @@ export interface GetBucketsCommandOutput extends GetBucketsResult, __MetadataBea
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetBucketsCommand extends $Command<GetBucketsCommandInput, GetBucketsCommandOutput, LightsailClientResolvedConfig> {

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

@@ -41,6 +41,30 @@ export interface GetBundlesCommandOutput extends GetBundlesResult, __MetadataBea
  * };
  * const command = new GetBundlesCommand(input);
  * const response = await client.send(command);
+ * // { // GetBundlesResult
+ * //   bundles: [ // BundleList
+ * //     { // Bundle
+ * //       price: Number("float"),
+ * //       cpuCount: Number("int"),
+ * //       diskSizeInGb: Number("int"),
+ * //       bundleId: "STRING_VALUE",
+ * //       instanceType: "STRING_VALUE",
+ * //       isActive: true || false,
+ * //       name: "STRING_VALUE",
+ * //       power: Number("int"),
+ * //       ramSizeInGb: Number("float"),
+ * //       transferPerMonthInGb: Number("int"),
+ * //       supportedPlatforms: [ // InstancePlatformList
+ * //         "LINUX_UNIX" || "WINDOWS",
+ * //       ],
+ * //       supportedAppCategories: [ // AppCategoryList
+ * //         "LfR",
+ * //       ],
+ * //     },
+ * //   ],
+ * //   nextPageToken: "STRING_VALUE",
+ * // };
+ *
  * ```
  *
  * @param GetBundlesCommandInput - {@link GetBundlesCommandInput}
@@ -79,6 +103,8 @@ export interface GetBundlesCommandOutput extends GetBundlesResult, __MetadataBea
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetBundlesCommand extends $Command<GetBundlesCommandInput, GetBundlesCommandOutput, LightsailClientResolvedConfig> {

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

@@ -40,6 +40,85 @@ export interface GetCertificatesCommandOutput extends GetCertificatesResult, __M
  * };
  * const command = new GetCertificatesCommand(input);
  * const response = await client.send(command);
+ * // { // GetCertificatesResult
+ * //   certificates: [ // CertificateSummaryList
+ * //     { // CertificateSummary
+ * //       certificateArn: "STRING_VALUE",
+ * //       certificateName: "STRING_VALUE",
+ * //       domainName: "STRING_VALUE",
+ * //       certificateDetail: { // Certificate
+ * //         arn: "STRING_VALUE",
+ * //         name: "STRING_VALUE",
+ * //         domainName: "STRING_VALUE",
+ * //         status: "PENDING_VALIDATION" || "ISSUED" || "INACTIVE" || "EXPIRED" || "VALIDATION_TIMED_OUT" || "REVOKED" || "FAILED",
+ * //         serialNumber: "STRING_VALUE",
+ * //         subjectAlternativeNames: [ // SubjectAlternativeNameList
+ * //           "STRING_VALUE",
+ * //         ],
+ * //         domainValidationRecords: [ // DomainValidationRecordList
+ * //           { // DomainValidationRecord
+ * //             domainName: "STRING_VALUE",
+ * //             resourceRecord: { // ResourceRecord
+ * //               name: "STRING_VALUE",
+ * //               type: "STRING_VALUE",
+ * //               value: "STRING_VALUE",
+ * //             },
+ * //             dnsRecordCreationState: { // DnsRecordCreationState
+ * //               code: "SUCCEEDED" || "STARTED" || "FAILED",
+ * //               message: "STRING_VALUE",
+ * //             },
+ * //             validationStatus: "PENDING_VALIDATION" || "FAILED" || "SUCCESS",
+ * //           },
+ * //         ],
+ * //         requestFailureReason: "STRING_VALUE",
+ * //         inUseResourceCount: Number("int"),
+ * //         keyAlgorithm: "STRING_VALUE",
+ * //         createdAt: new Date("TIMESTAMP"),
+ * //         issuedAt: new Date("TIMESTAMP"),
+ * //         issuerCA: "STRING_VALUE",
+ * //         notBefore: new Date("TIMESTAMP"),
+ * //         notAfter: new Date("TIMESTAMP"),
+ * //         eligibleToRenew: "STRING_VALUE",
+ * //         renewalSummary: { // RenewalSummary
+ * //           domainValidationRecords: [
+ * //             {
+ * //               domainName: "STRING_VALUE",
+ * //               resourceRecord: {
+ * //                 name: "STRING_VALUE",
+ * //                 type: "STRING_VALUE",
+ * //                 value: "STRING_VALUE",
+ * //               },
+ * //               dnsRecordCreationState: {
+ * //                 code: "SUCCEEDED" || "STARTED" || "FAILED",
+ * //                 message: "STRING_VALUE",
+ * //               },
+ * //               validationStatus: "PENDING_VALIDATION" || "FAILED" || "SUCCESS",
+ * //             },
+ * //           ],
+ * //           renewalStatus: "PendingAutoRenewal" || "PendingValidation" || "Success" || "Failed",
+ * //           renewalStatusReason: "STRING_VALUE",
+ * //           updatedAt: new Date("TIMESTAMP"),
+ * //         },
+ * //         revokedAt: new Date("TIMESTAMP"),
+ * //         revocationReason: "STRING_VALUE",
+ * //         tags: [ // TagList
+ * //           { // Tag
+ * //             key: "STRING_VALUE",
+ * //             value: "STRING_VALUE",
+ * //           },
+ * //         ],
+ * //         supportCode: "STRING_VALUE",
+ * //       },
+ * //       tags: [
+ * //         {
+ * //           key: "STRING_VALUE",
+ * //           value: "STRING_VALUE",
+ * //         },
+ * //       ],
+ * //     },
+ * //   ],
+ * // };
+ *
  * ```
  *
  * @param GetCertificatesCommandInput - {@link GetCertificatesCommandInput}
@@ -71,6 +150,8 @@ export interface GetCertificatesCommandOutput extends GetCertificatesResult, __M
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetCertificatesCommand extends $Command<GetCertificatesCommandInput, GetCertificatesCommandOutput, LightsailClientResolvedConfig> {

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

@@ -34,6 +34,34 @@ export interface GetCloudFormationStackRecordsCommandOutput extends GetCloudForm
  * };
  * const command = new GetCloudFormationStackRecordsCommand(input);
  * const response = await client.send(command);
+ * // { // GetCloudFormationStackRecordsResult
+ * //   cloudFormationStackRecords: [ // CloudFormationStackRecordList
+ * //     { // CloudFormationStackRecord
+ * //       name: "STRING_VALUE",
+ * //       arn: "STRING_VALUE",
+ * //       createdAt: new Date("TIMESTAMP"),
+ * //       location: { // ResourceLocation
+ * //         availabilityZone: "STRING_VALUE",
+ * //         regionName: "us-east-1" || "us-east-2" || "us-west-1" || "us-west-2" || "eu-west-1" || "eu-west-2" || "eu-west-3" || "eu-central-1" || "ca-central-1" || "ap-south-1" || "ap-southeast-1" || "ap-southeast-2" || "ap-northeast-1" || "ap-northeast-2" || "eu-north-1",
+ * //       },
+ * //       resourceType: "ContainerService" || "Instance" || "StaticIp" || "KeyPair" || "InstanceSnapshot" || "Domain" || "PeeredVpc" || "LoadBalancer" || "LoadBalancerTlsCertificate" || "Disk" || "DiskSnapshot" || "RelationalDatabase" || "RelationalDatabaseSnapshot" || "ExportSnapshotRecord" || "CloudFormationStackRecord" || "Alarm" || "ContactMethod" || "Distribution" || "Certificate" || "Bucket",
+ * //       state: "Started" || "Succeeded" || "Failed",
+ * //       sourceInfo: [ // CloudFormationStackRecordSourceInfoList
+ * //         { // CloudFormationStackRecordSourceInfo
+ * //           resourceType: "ExportSnapshotRecord",
+ * //           name: "STRING_VALUE",
+ * //           arn: "STRING_VALUE",
+ * //         },
+ * //       ],
+ * //       destinationInfo: { // DestinationInfo
+ * //         id: "STRING_VALUE",
+ * //         service: "STRING_VALUE",
+ * //       },
+ * //     },
+ * //   ],
+ * //   nextPageToken: "STRING_VALUE",
+ * // };
+ *
  * ```
  *
  * @param GetCloudFormationStackRecordsCommandInput - {@link GetCloudFormationStackRecordsCommandInput}
@@ -72,6 +100,8 @@ export interface GetCloudFormationStackRecordsCommandOutput extends GetCloudForm
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetCloudFormationStackRecordsCommand extends $Command<GetCloudFormationStackRecordsCommandInput, GetCloudFormationStackRecordsCommandOutput, LightsailClientResolvedConfig> {

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

@@ -38,6 +38,25 @@ export interface GetContactMethodsCommandOutput extends GetContactMethodsResult,
  * };
  * const command = new GetContactMethodsCommand(input);
  * const response = await client.send(command);
+ * // { // GetContactMethodsResult
+ * //   contactMethods: [ // ContactMethodsList
+ * //     { // ContactMethod
+ * //       contactEndpoint: "STRING_VALUE",
+ * //       status: "PendingVerification" || "Valid" || "Invalid",
+ * //       protocol: "Email" || "SMS",
+ * //       name: "STRING_VALUE",
+ * //       arn: "STRING_VALUE",
+ * //       createdAt: new Date("TIMESTAMP"),
+ * //       location: { // ResourceLocation
+ * //         availabilityZone: "STRING_VALUE",
+ * //         regionName: "us-east-1" || "us-east-2" || "us-west-1" || "us-west-2" || "eu-west-1" || "eu-west-2" || "eu-west-3" || "eu-central-1" || "ca-central-1" || "ap-south-1" || "ap-southeast-1" || "ap-southeast-2" || "ap-northeast-1" || "ap-northeast-2" || "eu-north-1",
+ * //       },
+ * //       resourceType: "ContainerService" || "Instance" || "StaticIp" || "KeyPair" || "InstanceSnapshot" || "Domain" || "PeeredVpc" || "LoadBalancer" || "LoadBalancerTlsCertificate" || "Disk" || "DiskSnapshot" || "RelationalDatabase" || "RelationalDatabaseSnapshot" || "ExportSnapshotRecord" || "CloudFormationStackRecord" || "Alarm" || "ContactMethod" || "Distribution" || "Certificate" || "Bucket",
+ * //       supportCode: "STRING_VALUE",
+ * //     },
+ * //   ],
+ * // };
+ *
  * ```
  *
  * @param GetContactMethodsCommandInput - {@link GetContactMethodsCommandInput}
@@ -72,6 +91,8 @@ export interface GetContactMethodsCommandOutput extends GetContactMethodsResult,
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetContactMethodsCommand extends $Command<GetContactMethodsCommandInput, GetContactMethodsCommandOutput, LightsailClientResolvedConfig> {

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

@@ -30,6 +30,14 @@ export interface GetContainerAPIMetadataCommandOutput extends GetContainerAPIMet
  * const input = {};
  * const command = new GetContainerAPIMetadataCommand(input);
  * const response = await client.send(command);
+ * // { // GetContainerAPIMetadataResult
+ * //   metadata: [ // ContainerServiceMetadataEntryList
+ * //     { // ContainerServiceMetadataEntry
+ * //       "<keys>": "STRING_VALUE",
+ * //     },
+ * //   ],
+ * // };
+ *
  * ```
  *
  * @param GetContainerAPIMetadataCommandInput - {@link GetContainerAPIMetadataCommandInput}
@@ -48,6 +56,8 @@ export interface GetContainerAPIMetadataCommandOutput extends GetContainerAPIMet
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetContainerAPIMetadataCommand extends $Command<GetContainerAPIMetadataCommandInput, GetContainerAPIMetadataCommandOutput, LightsailClientResolvedConfig> {

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

@@ -37,6 +37,16 @@ export interface GetContainerImagesCommandOutput extends GetContainerImagesResul
  * };
  * const command = new GetContainerImagesCommand(input);
  * const response = await client.send(command);
+ * // { // GetContainerImagesResult
+ * //   containerImages: [ // ContainerImageList
+ * //     { // ContainerImage
+ * //       image: "STRING_VALUE",
+ * //       digest: "STRING_VALUE",
+ * //       createdAt: new Date("TIMESTAMP"),
+ * //     },
+ * //   ],
+ * // };
+ *
  * ```
  *
  * @param GetContainerImagesCommandInput - {@link GetContainerImagesCommandInput}
@@ -68,6 +78,8 @@ export interface GetContainerImagesCommandOutput extends GetContainerImagesResul
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetContainerImagesCommand extends $Command<GetContainerImagesCommandInput, GetContainerImagesCommandOutput, LightsailClientResolvedConfig> {

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

@@ -45,6 +45,16 @@ export interface GetContainerLogCommandOutput extends GetContainerLogResult, __M
  * };
  * const command = new GetContainerLogCommand(input);
  * const response = await client.send(command);
+ * // { // GetContainerLogResult
+ * //   logEvents: [ // ContainerServiceLogEventList
+ * //     { // ContainerServiceLogEvent
+ * //       createdAt: new Date("TIMESTAMP"),
+ * //       message: "STRING_VALUE",
+ * //     },
+ * //   ],
+ * //   nextPageToken: "STRING_VALUE",
+ * // };
+ *
  * ```
  *
  * @param GetContainerLogCommandInput - {@link GetContainerLogCommandInput}
@@ -76,6 +86,8 @@ export interface GetContainerLogCommandOutput extends GetContainerLogResult, __M
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetContainerLogCommand extends $Command<GetContainerLogCommandInput, GetContainerLogCommandOutput, LightsailClientResolvedConfig> {

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

@@ -41,6 +41,42 @@ export interface GetContainerServiceDeploymentsCommandOutput extends GetContaine
  * };
  * const command = new GetContainerServiceDeploymentsCommand(input);
  * const response = await client.send(command);
+ * // { // GetContainerServiceDeploymentsResult
+ * //   deployments: [ // ContainerServiceDeploymentList
+ * //     { // ContainerServiceDeployment
+ * //       version: Number("int"),
+ * //       state: "ACTIVATING" || "ACTIVE" || "INACTIVE" || "FAILED",
+ * //       containers: { // ContainerMap
+ * //         "<keys>": { // Container
+ * //           image: "STRING_VALUE",
+ * //           command: [ // StringList
+ * //             "STRING_VALUE",
+ * //           ],
+ * //           environment: { // Environment
+ * //             "<keys>": "STRING_VALUE",
+ * //           },
+ * //           ports: { // PortMap
+ * //             "<keys>": "HTTP" || "HTTPS" || "TCP" || "UDP",
+ * //           },
+ * //         },
+ * //       },
+ * //       publicEndpoint: { // ContainerServiceEndpoint
+ * //         containerName: "STRING_VALUE",
+ * //         containerPort: Number("int"),
+ * //         healthCheck: { // ContainerServiceHealthCheckConfig
+ * //           healthyThreshold: Number("int"),
+ * //           unhealthyThreshold: Number("int"),
+ * //           timeoutSeconds: Number("int"),
+ * //           intervalSeconds: Number("int"),
+ * //           path: "STRING_VALUE",
+ * //           successCodes: "STRING_VALUE",
+ * //         },
+ * //       },
+ * //       createdAt: new Date("TIMESTAMP"),
+ * //     },
+ * //   ],
+ * // };
+ *
  * ```
  *
  * @param GetContainerServiceDeploymentsCommandInput - {@link GetContainerServiceDeploymentsCommandInput}
@@ -72,6 +108,8 @@ export interface GetContainerServiceDeploymentsCommandOutput extends GetContaine
  * @throws {@link UnauthenticatedException} (client fault)
  *  <p>Lightsail throws this exception when the user has not been authenticated.</p>
  *
+ * @throws {@link LightsailServiceException}
+ * <p>Base exception class for all service exceptions from Lightsail service.</p>
  *
  */
 export declare class GetContainerServiceDeploymentsCommand extends $Command<GetContainerServiceDeploymentsCommandInput, GetContainerServiceDeploymentsCommandOutput, LightsailClientResolvedConfig> {