@aws-sdk/client-lightsail 3.934.0 → 3.935.0

package/dist-types/ts3.4/models/enums.d.ts

@@ -0,0 +1,776 @@
+export declare const AccessDirection: {
+  readonly inbound: "inbound";
+  readonly outbound: "outbound";
+};
+export type AccessDirection =
+  (typeof AccessDirection)[keyof typeof AccessDirection];
+export declare const StatusType: {
+  readonly Active: "Active";
+  readonly Inactive: "Inactive";
+};
+export type StatusType = (typeof StatusType)[keyof typeof StatusType];
+export declare const AccessType: {
+  readonly Private: "private";
+  readonly Public: "public";
+};
+export type AccessType = (typeof AccessType)[keyof typeof AccessType];
+export declare const BPAStatusMessage: {
+  readonly DEFAULTED_FOR_SLR_MISSING: "DEFAULTED_FOR_SLR_MISSING";
+  readonly DEFAULTED_FOR_SLR_MISSING_ON_HOLD: "DEFAULTED_FOR_SLR_MISSING_ON_HOLD";
+  readonly SYNC_ON_HOLD: "SYNC_ON_HOLD";
+  readonly Unknown: "Unknown";
+};
+export type BPAStatusMessage =
+  (typeof BPAStatusMessage)[keyof typeof BPAStatusMessage];
+export declare const AccountLevelBpaSyncStatus: {
+  readonly Defaulted: "Defaulted";
+  readonly Failed: "Failed";
+  readonly InSync: "InSync";
+  readonly NeverSynced: "NeverSynced";
+};
+export type AccountLevelBpaSyncStatus =
+  (typeof AccountLevelBpaSyncStatus)[keyof typeof AccountLevelBpaSyncStatus];
+export declare const AddOnType: {
+  readonly AutoSnapshot: "AutoSnapshot";
+  readonly StopInstanceOnIdle: "StopInstanceOnIdle";
+};
+export type AddOnType = (typeof AddOnType)[keyof typeof AddOnType];
+export declare const ComparisonOperator: {
+  readonly GreaterThanOrEqualToThreshold: "GreaterThanOrEqualToThreshold";
+  readonly GreaterThanThreshold: "GreaterThanThreshold";
+  readonly LessThanOrEqualToThreshold: "LessThanOrEqualToThreshold";
+  readonly LessThanThreshold: "LessThanThreshold";
+};
+export type ComparisonOperator =
+  (typeof ComparisonOperator)[keyof typeof ComparisonOperator];
+export declare const ContactProtocol: {
+  readonly Email: "Email";
+  readonly SMS: "SMS";
+};
+export type ContactProtocol =
+  (typeof ContactProtocol)[keyof typeof ContactProtocol];
+export declare const RegionName: {
+  readonly AP_NORTHEAST_1: "ap-northeast-1";
+  readonly AP_NORTHEAST_2: "ap-northeast-2";
+  readonly AP_SOUTHEAST_1: "ap-southeast-1";
+  readonly AP_SOUTHEAST_2: "ap-southeast-2";
+  readonly AP_SOUTHEAST_3: "ap-southeast-3";
+  readonly AP_SOUTH_1: "ap-south-1";
+  readonly CA_CENTRAL_1: "ca-central-1";
+  readonly EU_CENTRAL_1: "eu-central-1";
+  readonly EU_NORTH_1: "eu-north-1";
+  readonly EU_WEST_1: "eu-west-1";
+  readonly EU_WEST_2: "eu-west-2";
+  readonly EU_WEST_3: "eu-west-3";
+  readonly US_EAST_1: "us-east-1";
+  readonly US_EAST_2: "us-east-2";
+  readonly US_WEST_1: "us-west-1";
+  readonly US_WEST_2: "us-west-2";
+};
+export type RegionName = (typeof RegionName)[keyof typeof RegionName];
+export declare const MetricName: {
+  readonly BurstCapacityPercentage: "BurstCapacityPercentage";
+  readonly BurstCapacityTime: "BurstCapacityTime";
+  readonly CPUUtilization: "CPUUtilization";
+  readonly ClientTLSNegotiationErrorCount: "ClientTLSNegotiationErrorCount";
+  readonly DatabaseConnections: "DatabaseConnections";
+  readonly DiskQueueDepth: "DiskQueueDepth";
+  readonly FreeStorageSpace: "FreeStorageSpace";
+  readonly HTTPCode_Instance_2XX_Count: "HTTPCode_Instance_2XX_Count";
+  readonly HTTPCode_Instance_3XX_Count: "HTTPCode_Instance_3XX_Count";
+  readonly HTTPCode_Instance_4XX_Count: "HTTPCode_Instance_4XX_Count";
+  readonly HTTPCode_Instance_5XX_Count: "HTTPCode_Instance_5XX_Count";
+  readonly HTTPCode_LB_4XX_Count: "HTTPCode_LB_4XX_Count";
+  readonly HTTPCode_LB_5XX_Count: "HTTPCode_LB_5XX_Count";
+  readonly HealthyHostCount: "HealthyHostCount";
+  readonly InstanceResponseTime: "InstanceResponseTime";
+  readonly NetworkIn: "NetworkIn";
+  readonly NetworkOut: "NetworkOut";
+  readonly NetworkReceiveThroughput: "NetworkReceiveThroughput";
+  readonly NetworkTransmitThroughput: "NetworkTransmitThroughput";
+  readonly RejectedConnectionCount: "RejectedConnectionCount";
+  readonly RequestCount: "RequestCount";
+  readonly StatusCheckFailed: "StatusCheckFailed";
+  readonly StatusCheckFailed_Instance: "StatusCheckFailed_Instance";
+  readonly StatusCheckFailed_System: "StatusCheckFailed_System";
+  readonly UnhealthyHostCount: "UnhealthyHostCount";
+};
+export type MetricName = (typeof MetricName)[keyof typeof MetricName];
+export declare const ResourceType: {
+  readonly Alarm: "Alarm";
+  readonly Bucket: "Bucket";
+  readonly Certificate: "Certificate";
+  readonly CloudFormationStackRecord: "CloudFormationStackRecord";
+  readonly ContactMethod: "ContactMethod";
+  readonly ContainerService: "ContainerService";
+  readonly Disk: "Disk";
+  readonly DiskSnapshot: "DiskSnapshot";
+  readonly Distribution: "Distribution";
+  readonly Domain: "Domain";
+  readonly ExportSnapshotRecord: "ExportSnapshotRecord";
+  readonly Instance: "Instance";
+  readonly InstanceSnapshot: "InstanceSnapshot";
+  readonly KeyPair: "KeyPair";
+  readonly LoadBalancer: "LoadBalancer";
+  readonly LoadBalancerTlsCertificate: "LoadBalancerTlsCertificate";
+  readonly PeeredVpc: "PeeredVpc";
+  readonly RelationalDatabase: "RelationalDatabase";
+  readonly RelationalDatabaseSnapshot: "RelationalDatabaseSnapshot";
+  readonly StaticIp: "StaticIp";
+};
+export type ResourceType = (typeof ResourceType)[keyof typeof ResourceType];
+export declare const AlarmState: {
+  readonly ALARM: "ALARM";
+  readonly INSUFFICIENT_DATA: "INSUFFICIENT_DATA";
+  readonly OK: "OK";
+};
+export type AlarmState = (typeof AlarmState)[keyof typeof AlarmState];
+export declare const MetricStatistic: {
+  readonly Average: "Average";
+  readonly Maximum: "Maximum";
+  readonly Minimum: "Minimum";
+  readonly SampleCount: "SampleCount";
+  readonly Sum: "Sum";
+};
+export type MetricStatistic =
+  (typeof MetricStatistic)[keyof typeof MetricStatistic];
+export declare const TreatMissingData: {
+  readonly Breaching: "breaching";
+  readonly Ignore: "ignore";
+  readonly Missing: "missing";
+  readonly NotBreaching: "notBreaching";
+};
+export type TreatMissingData =
+  (typeof TreatMissingData)[keyof typeof TreatMissingData];
+export declare const MetricUnit: {
+  readonly Bits: "Bits";
+  readonly BitsSecond: "Bits/Second";
+  readonly Bytes: "Bytes";
+  readonly BytesSecond: "Bytes/Second";
+  readonly Count: "Count";
+  readonly CountSecond: "Count/Second";
+  readonly Gigabits: "Gigabits";
+  readonly GigabitsSecond: "Gigabits/Second";
+  readonly Gigabytes: "Gigabytes";
+  readonly GigabytesSecond: "Gigabytes/Second";
+  readonly Kilobits: "Kilobits";
+  readonly KilobitsSecond: "Kilobits/Second";
+  readonly Kilobytes: "Kilobytes";
+  readonly KilobytesSecond: "Kilobytes/Second";
+  readonly Megabits: "Megabits";
+  readonly MegabitsSecond: "Megabits/Second";
+  readonly Megabytes: "Megabytes";
+  readonly MegabytesSecond: "Megabytes/Second";
+  readonly Microseconds: "Microseconds";
+  readonly Milliseconds: "Milliseconds";
+  readonly None: "None";
+  readonly Percent: "Percent";
+  readonly Seconds: "Seconds";
+  readonly Terabits: "Terabits";
+  readonly TerabitsSecond: "Terabits/Second";
+  readonly Terabytes: "Terabytes";
+  readonly TerabytesSecond: "Terabytes/Second";
+};
+export type MetricUnit = (typeof MetricUnit)[keyof typeof MetricUnit];
+export declare const OperationType: {
+  readonly AllocateStaticIp: "AllocateStaticIp";
+  readonly AttachCertificateToDistribution: "AttachCertificateToDistribution";
+  readonly AttachDisk: "AttachDisk";
+  readonly AttachInstancesToLoadBalancer: "AttachInstancesToLoadBalancer";
+  readonly AttachLoadBalancerTlsCertificate: "AttachLoadBalancerTlsCertificate";
+  readonly AttachStaticIp: "AttachStaticIp";
+  readonly CloseInstancePublicPorts: "CloseInstancePublicPorts";
+  readonly CreateBucket: "CreateBucket";
+  readonly CreateBucketAccessKey: "CreateBucketAccessKey";
+  readonly CreateCertificate: "CreateCertificate";
+  readonly CreateContactMethod: "CreateContactMethod";
+  readonly CreateContainerService: "CreateContainerService";
+  readonly CreateContainerServiceDeployment: "CreateContainerServiceDeployment";
+  readonly CreateContainerServiceRegistryLogin: "CreateContainerServiceRegistryLogin";
+  readonly CreateDisk: "CreateDisk";
+  readonly CreateDiskFromSnapshot: "CreateDiskFromSnapshot";
+  readonly CreateDiskSnapshot: "CreateDiskSnapshot";
+  readonly CreateDistribution: "CreateDistribution";
+  readonly CreateDomain: "CreateDomain";
+  readonly CreateInstance: "CreateInstance";
+  readonly CreateInstanceSnapshot: "CreateInstanceSnapshot";
+  readonly CreateInstancesFromSnapshot: "CreateInstancesFromSnapshot";
+  readonly CreateLoadBalancer: "CreateLoadBalancer";
+  readonly CreateLoadBalancerTlsCertificate: "CreateLoadBalancerTlsCertificate";
+  readonly CreateRelationalDatabase: "CreateRelationalDatabase";
+  readonly CreateRelationalDatabaseFromSnapshot: "CreateRelationalDatabaseFromSnapshot";
+  readonly CreateRelationalDatabaseSnapshot: "CreateRelationalDatabaseSnapshot";
+  readonly DeleteAlarm: "DeleteAlarm";
+  readonly DeleteBucket: "DeleteBucket";
+  readonly DeleteBucketAccessKey: "DeleteBucketAccessKey";
+  readonly DeleteCertificate: "DeleteCertificate";
+  readonly DeleteContactMethod: "DeleteContactMethod";
+  readonly DeleteContainerImage: "DeleteContainerImage";
+  readonly DeleteContainerService: "DeleteContainerService";
+  readonly DeleteDisk: "DeleteDisk";
+  readonly DeleteDiskSnapshot: "DeleteDiskSnapshot";
+  readonly DeleteDistribution: "DeleteDistribution";
+  readonly DeleteDomain: "DeleteDomain";
+  readonly DeleteDomainEntry: "DeleteDomainEntry";
+  readonly DeleteInstance: "DeleteInstance";
+  readonly DeleteInstanceSnapshot: "DeleteInstanceSnapshot";
+  readonly DeleteKnownHostKeys: "DeleteKnownHostKeys";
+  readonly DeleteLoadBalancer: "DeleteLoadBalancer";
+  readonly DeleteLoadBalancerTlsCertificate: "DeleteLoadBalancerTlsCertificate";
+  readonly DeleteRelationalDatabase: "DeleteRelationalDatabase";
+  readonly DeleteRelationalDatabaseSnapshot: "DeleteRelationalDatabaseSnapshot";
+  readonly DetachCertificateFromDistribution: "DetachCertificateFromDistribution";
+  readonly DetachDisk: "DetachDisk";
+  readonly DetachInstancesFromLoadBalancer: "DetachInstancesFromLoadBalancer";
+  readonly DetachStaticIp: "DetachStaticIp";
+  readonly DisableAddOn: "DisableAddOn";
+  readonly EnableAddOn: "EnableAddOn";
+  readonly GetAlarms: "GetAlarms";
+  readonly GetContactMethods: "GetContactMethods";
+  readonly OpenInstancePublicPorts: "OpenInstancePublicPorts";
+  readonly PutAlarm: "PutAlarm";
+  readonly PutInstancePublicPorts: "PutInstancePublicPorts";
+  readonly RebootInstance: "RebootInstance";
+  readonly RebootRelationalDatabase: "RebootRelationalDatabase";
+  readonly RegisterContainerImage: "RegisterContainerImage";
+  readonly ReleaseStaticIp: "ReleaseStaticIp";
+  readonly ResetDistributionCache: "ResetDistributionCache";
+  readonly SendContactMethodVerification: "SendContactMethodVerification";
+  readonly SetIpAddressType: "SetIpAddressType";
+  readonly SetResourceAccessForBucket: "SetResourceAccessForBucket";
+  readonly SetupInstanceHttps: "SetupInstanceHttps";
+  readonly StartGUISession: "StartGUISession";
+  readonly StartInstance: "StartInstance";
+  readonly StartRelationalDatabase: "StartRelationalDatabase";
+  readonly StopGUISession: "StopGUISession";
+  readonly StopInstance: "StopInstance";
+  readonly StopRelationalDatabase: "StopRelationalDatabase";
+  readonly TestAlarm: "TestAlarm";
+  readonly UpdateBucket: "UpdateBucket";
+  readonly UpdateBucketBundle: "UpdateBucketBundle";
+  readonly UpdateContainerService: "UpdateContainerService";
+  readonly UpdateDistribution: "UpdateDistribution";
+  readonly UpdateDistributionBundle: "UpdateDistributionBundle";
+  readonly UpdateDomainEntry: "UpdateDomainEntry";
+  readonly UpdateInstanceMetadataOptions: "UpdateInstanceMetadataOptions";
+  readonly UpdateLoadBalancerAttribute: "UpdateLoadBalancerAttribute";
+  readonly UpdateRelationalDatabase: "UpdateRelationalDatabase";
+  readonly UpdateRelationalDatabaseParameters: "UpdateRelationalDatabaseParameters";
+};
+export type OperationType = (typeof OperationType)[keyof typeof OperationType];
+export declare const OperationStatus: {
+  readonly Completed: "Completed";
+  readonly Failed: "Failed";
+  readonly NotStarted: "NotStarted";
+  readonly Started: "Started";
+  readonly Succeeded: "Succeeded";
+};
+export type OperationStatus =
+  (typeof OperationStatus)[keyof typeof OperationStatus];
+export declare const AppCategory: {
+  readonly LfR: "LfR";
+};
+export type AppCategory = (typeof AppCategory)[keyof typeof AppCategory];
+export declare const AutoMountStatus: {
+  readonly Failed: "Failed";
+  readonly Mounted: "Mounted";
+  readonly NotMounted: "NotMounted";
+  readonly Pending: "Pending";
+};
+export type AutoMountStatus =
+  (typeof AutoMountStatus)[keyof typeof AutoMountStatus];
+export declare const AutoSnapshotStatus: {
+  readonly FAILED: "Failed";
+  readonly IN_PROGRESS: "InProgress";
+  readonly NOT_FOUND: "NotFound";
+  readonly SUCCESS: "Success";
+};
+export type AutoSnapshotStatus =
+  (typeof AutoSnapshotStatus)[keyof typeof AutoSnapshotStatus];
+export declare const BehaviorEnum: {
+  readonly CacheSetting: "cache";
+  readonly DontCacheSetting: "dont-cache";
+};
+export type BehaviorEnum = (typeof BehaviorEnum)[keyof typeof BehaviorEnum];
+export declare const InstancePlatform: {
+  readonly LinuxUnix: "LINUX_UNIX";
+  readonly Windows: "WINDOWS";
+};
+export type InstancePlatform =
+  (typeof InstancePlatform)[keyof typeof InstancePlatform];
+export declare const BlueprintType: {
+  readonly app: "app";
+  readonly os: "os";
+};
+export type BlueprintType = (typeof BlueprintType)[keyof typeof BlueprintType];
+export declare const BucketMetricName: {
+  readonly BucketSizeBytes: "BucketSizeBytes";
+  readonly NumberOfObjects: "NumberOfObjects";
+};
+export type BucketMetricName =
+  (typeof BucketMetricName)[keyof typeof BucketMetricName];
+export declare const ForwardValues: {
+  readonly all: "all";
+  readonly allowList: "allow-list";
+  readonly none: "none";
+};
+export type ForwardValues = (typeof ForwardValues)[keyof typeof ForwardValues];
+export declare const HeaderEnum: {
+  readonly accept: "Accept";
+  readonly acceptCharset: "Accept-Charset";
+  readonly acceptDatetime: "Accept-Datetime";
+  readonly acceptEncoding: "Accept-Encoding";
+  readonly acceptLanguage: "Accept-Language";
+  readonly authorization: "Authorization";
+  readonly cloudFrontForwardedProto: "CloudFront-Forwarded-Proto";
+  readonly cloudFrontIsDesktopViewer: "CloudFront-Is-Desktop-Viewer";
+  readonly cloudFrontIsMobileViewer: "CloudFront-Is-Mobile-Viewer";
+  readonly cloudFrontIsSmartTVViewer: "CloudFront-Is-SmartTV-Viewer";
+  readonly cloudFrontIsTabletViewer: "CloudFront-Is-Tablet-Viewer";
+  readonly cloudFrontViewerCountry: "CloudFront-Viewer-Country";
+  readonly host: "Host";
+  readonly origin: "Origin";
+  readonly referer: "Referer";
+};
+export type HeaderEnum = (typeof HeaderEnum)[keyof typeof HeaderEnum];
+export declare const DnsRecordCreationStateCode: {
+  readonly Failed: "FAILED";
+  readonly Started: "STARTED";
+  readonly Succeeded: "SUCCEEDED";
+};
+export type DnsRecordCreationStateCode =
+  (typeof DnsRecordCreationStateCode)[keyof typeof DnsRecordCreationStateCode];
+export declare const CertificateDomainValidationStatus: {
+  readonly Failed: "FAILED";
+  readonly PendingValidation: "PENDING_VALIDATION";
+  readonly Success: "SUCCESS";
+};
+export type CertificateDomainValidationStatus =
+  (typeof CertificateDomainValidationStatus)[keyof typeof CertificateDomainValidationStatus];
+export declare const RenewalStatus: {
+  readonly Failed: "Failed";
+  readonly PendingAutoRenewal: "PendingAutoRenewal";
+  readonly PendingValidation: "PendingValidation";
+  readonly Success: "Success";
+};
+export type RenewalStatus = (typeof RenewalStatus)[keyof typeof RenewalStatus];
+export declare const CertificateStatus: {
+  readonly Expired: "EXPIRED";
+  readonly Failed: "FAILED";
+  readonly Inactive: "INACTIVE";
+  readonly Issued: "ISSUED";
+  readonly PendingValidation: "PENDING_VALIDATION";
+  readonly Revoked: "REVOKED";
+  readonly ValidationTimedOut: "VALIDATION_TIMED_OUT";
+};
+export type CertificateStatus =
+  (typeof CertificateStatus)[keyof typeof CertificateStatus];
+export declare const CertificateProvider: {
+  readonly LetsEncrypt: "LetsEncrypt";
+};
+export type CertificateProvider =
+  (typeof CertificateProvider)[keyof typeof CertificateProvider];
+export declare const NetworkProtocol: {
+  readonly ALL: "all";
+  readonly ICMP: "icmp";
+  readonly ICMPV6: "icmpv6";
+  readonly TCP: "tcp";
+  readonly UDP: "udp";
+};
+export type NetworkProtocol =
+  (typeof NetworkProtocol)[keyof typeof NetworkProtocol];
+export declare const CloudFormationStackRecordSourceType: {
+  readonly ExportSnapshotRecord: "ExportSnapshotRecord";
+};
+export type CloudFormationStackRecordSourceType =
+  (typeof CloudFormationStackRecordSourceType)[keyof typeof CloudFormationStackRecordSourceType];
+export declare const RecordState: {
+  readonly Failed: "Failed";
+  readonly Started: "Started";
+  readonly Succeeded: "Succeeded";
+};
+export type RecordState = (typeof RecordState)[keyof typeof RecordState];
+export declare const ContactMethodStatus: {
+  readonly Invalid: "Invalid";
+  readonly PendingVerification: "PendingVerification";
+  readonly Valid: "Valid";
+};
+export type ContactMethodStatus =
+  (typeof ContactMethodStatus)[keyof typeof ContactMethodStatus];
+export declare const ContactMethodVerificationProtocol: {
+  readonly Email: "Email";
+};
+export type ContactMethodVerificationProtocol =
+  (typeof ContactMethodVerificationProtocol)[keyof typeof ContactMethodVerificationProtocol];
+export declare const ContainerServiceProtocol: {
+  readonly HTTP: "HTTP";
+  readonly HTTPS: "HTTPS";
+  readonly TCP: "TCP";
+  readonly UDP: "UDP";
+};
+export type ContainerServiceProtocol =
+  (typeof ContainerServiceProtocol)[keyof typeof ContainerServiceProtocol];
+export declare const ContainerServiceDeploymentState: {
+  readonly ACTIVATING: "ACTIVATING";
+  readonly ACTIVE: "ACTIVE";
+  readonly FAILED: "FAILED";
+  readonly INACTIVE: "INACTIVE";
+};
+export type ContainerServiceDeploymentState =
+  (typeof ContainerServiceDeploymentState)[keyof typeof ContainerServiceDeploymentState];
+export declare const ContainerServicePowerName: {
+  readonly large: "large";
+  readonly medium: "medium";
+  readonly micro: "micro";
+  readonly nano: "nano";
+  readonly small: "small";
+  readonly xlarge: "xlarge";
+};
+export type ContainerServicePowerName =
+  (typeof ContainerServicePowerName)[keyof typeof ContainerServicePowerName];
+export declare const ContainerServiceState: {
+  readonly DELETING: "DELETING";
+  readonly DEPLOYING: "DEPLOYING";
+  readonly DISABLED: "DISABLED";
+  readonly PENDING: "PENDING";
+  readonly READY: "READY";
+  readonly RUNNING: "RUNNING";
+  readonly UPDATING: "UPDATING";
+};
+export type ContainerServiceState =
+  (typeof ContainerServiceState)[keyof typeof ContainerServiceState];
+export declare const ContainerServiceStateDetailCode: {
+  readonly ACTIVATING_DEPLOYMENT: "ACTIVATING_DEPLOYMENT";
+  readonly CERTIFICATE_LIMIT_EXCEEDED: "CERTIFICATE_LIMIT_EXCEEDED";
+  readonly CREATING_DEPLOYMENT: "CREATING_DEPLOYMENT";
+  readonly CREATING_NETWORK_INFRASTRUCTURE: "CREATING_NETWORK_INFRASTRUCTURE";
+  readonly CREATING_SYSTEM_RESOURCES: "CREATING_SYSTEM_RESOURCES";
+  readonly EVALUATING_HEALTH_CHECK: "EVALUATING_HEALTH_CHECK";
+  readonly PROVISIONING_CERTIFICATE: "PROVISIONING_CERTIFICATE";
+  readonly PROVISIONING_SERVICE: "PROVISIONING_SERVICE";
+  readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+};
+export type ContainerServiceStateDetailCode =
+  (typeof ContainerServiceStateDetailCode)[keyof typeof ContainerServiceStateDetailCode];
+export declare const ContainerServiceMetricName: {
+  readonly CPUUtilization: "CPUUtilization";
+  readonly MemoryUtilization: "MemoryUtilization";
+};
+export type ContainerServiceMetricName =
+  (typeof ContainerServiceMetricName)[keyof typeof ContainerServiceMetricName];
+export declare const Currency: {
+  readonly USD: "USD";
+};
+export type Currency = (typeof Currency)[keyof typeof Currency];
+export declare const PricingUnit: {
+  readonly Bundles: "Bundles";
+  readonly GB: "GB";
+  readonly GBMo: "GB-Mo";
+  readonly Hrs: "Hrs";
+  readonly Queries: "Queries";
+};
+export type PricingUnit = (typeof PricingUnit)[keyof typeof PricingUnit];
+export declare const PortInfoSourceType: {
+  readonly Closed: "CLOSED";
+  readonly Default: "DEFAULT";
+  readonly Instance: "INSTANCE";
+  readonly None: "NONE";
+};
+export type PortInfoSourceType =
+  (typeof PortInfoSourceType)[keyof typeof PortInfoSourceType];
+export declare const IpAddressType: {
+  readonly DUALSTACK: "dualstack";
+  readonly IPV4: "ipv4";
+  readonly IPV6: "ipv6";
+};
+export type IpAddressType = (typeof IpAddressType)[keyof typeof IpAddressType];
+export declare const OriginProtocolPolicyEnum: {
+  readonly HTTPOnly: "http-only";
+  readonly HTTPSOnly: "https-only";
+};
+export type OriginProtocolPolicyEnum =
+  (typeof OriginProtocolPolicyEnum)[keyof typeof OriginProtocolPolicyEnum];
+export declare const ViewerMinimumTlsProtocolVersionEnum: {
+  readonly TLSv11_2016: "TLSv1.1_2016";
+  readonly TLSv12_2018: "TLSv1.2_2018";
+  readonly TLSv12_2019: "TLSv1.2_2019";
+  readonly TLSv12_2021: "TLSv1.2_2021";
+};
+export type ViewerMinimumTlsProtocolVersionEnum =
+  (typeof ViewerMinimumTlsProtocolVersionEnum)[keyof typeof ViewerMinimumTlsProtocolVersionEnum];
+export declare const Status: {
+  readonly FailedInstanceCreation: "failedInstanceCreation";
+  readonly FailedStartingGUISession: "failedStartingGUISession";
+  readonly FailedStoppingGUISession: "failedStoppingGUISession";
+  readonly NotStarted: "notStarted";
+  readonly SettingUpInstance: "settingUpInstance";
+  readonly StartExpired: "startExpired";
+  readonly Started: "started";
+  readonly Starting: "starting";
+  readonly Stopped: "stopped";
+  readonly Stopping: "stopping";
+};
+export type Status = (typeof Status)[keyof typeof Status];
+export declare const DiskState: {
+  readonly Available: "available";
+  readonly Error: "error";
+  readonly InUse: "in-use";
+  readonly Pending: "pending";
+  readonly Unknown: "unknown";
+};
+export type DiskState = (typeof DiskState)[keyof typeof DiskState];
+export declare const DiskSnapshotState: {
+  readonly Completed: "completed";
+  readonly Error: "error";
+  readonly Pending: "pending";
+  readonly Unknown: "unknown";
+};
+export type DiskSnapshotState =
+  (typeof DiskSnapshotState)[keyof typeof DiskSnapshotState];
+export declare const DistributionMetricName: {
+  readonly BytesDownloaded: "BytesDownloaded";
+  readonly BytesUploaded: "BytesUploaded";
+  readonly Http4xxErrorRate: "Http4xxErrorRate";
+  readonly Http5xxErrorRate: "Http5xxErrorRate";
+  readonly Requests: "Requests";
+  readonly TotalErrorRate: "TotalErrorRate";
+};
+export type DistributionMetricName =
+  (typeof DistributionMetricName)[keyof typeof DistributionMetricName];
+export declare const NameServersUpdateStateCode: {
+  readonly Failed: "FAILED";
+  readonly Pending: "PENDING";
+  readonly Started: "STARTED";
+  readonly Succeeded: "SUCCEEDED";
+};
+export type NameServersUpdateStateCode =
+  (typeof NameServersUpdateStateCode)[keyof typeof NameServersUpdateStateCode];
+export declare const R53HostedZoneDeletionStateCode: {
+  readonly Failed: "FAILED";
+  readonly Pending: "PENDING";
+  readonly Started: "STARTED";
+  readonly Succeeded: "SUCCEEDED";
+};
+export type R53HostedZoneDeletionStateCode =
+  (typeof R53HostedZoneDeletionStateCode)[keyof typeof R53HostedZoneDeletionStateCode];
+export declare const ExportSnapshotRecordSourceType: {
+  readonly DiskSnapshot: "DiskSnapshot";
+  readonly InstanceSnapshot: "InstanceSnapshot";
+};
+export type ExportSnapshotRecordSourceType =
+  (typeof ExportSnapshotRecordSourceType)[keyof typeof ExportSnapshotRecordSourceType];
+export declare const HttpEndpoint: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+};
+export type HttpEndpoint = (typeof HttpEndpoint)[keyof typeof HttpEndpoint];
+export declare const HttpProtocolIpv6: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+};
+export type HttpProtocolIpv6 =
+  (typeof HttpProtocolIpv6)[keyof typeof HttpProtocolIpv6];
+export declare const HttpTokens: {
+  readonly optional: "optional";
+  readonly required: "required";
+};
+export type HttpTokens = (typeof HttpTokens)[keyof typeof HttpTokens];
+export declare const InstanceMetadataState: {
+  readonly applied: "applied";
+  readonly pending: "pending";
+};
+export type InstanceMetadataState =
+  (typeof InstanceMetadataState)[keyof typeof InstanceMetadataState];
+export declare const PortAccessType: {
+  readonly Private: "Private";
+  readonly Public: "Public";
+};
+export type PortAccessType =
+  (typeof PortAccessType)[keyof typeof PortAccessType];
+export declare const InstanceAccessProtocol: {
+  readonly rdp: "rdp";
+  readonly ssh: "ssh";
+};
+export type InstanceAccessProtocol =
+  (typeof InstanceAccessProtocol)[keyof typeof InstanceAccessProtocol];
+export declare const InstanceMetricName: {
+  readonly BurstCapacityPercentage: "BurstCapacityPercentage";
+  readonly BurstCapacityTime: "BurstCapacityTime";
+  readonly CPUUtilization: "CPUUtilization";
+  readonly MetadataNoToken: "MetadataNoToken";
+  readonly NetworkIn: "NetworkIn";
+  readonly NetworkOut: "NetworkOut";
+  readonly StatusCheckFailed: "StatusCheckFailed";
+  readonly StatusCheckFailed_Instance: "StatusCheckFailed_Instance";
+  readonly StatusCheckFailed_System: "StatusCheckFailed_System";
+};
+export type InstanceMetricName =
+  (typeof InstanceMetricName)[keyof typeof InstanceMetricName];
+export declare const PortState: {
+  readonly Closed: "closed";
+  readonly Open: "open";
+};
+export type PortState = (typeof PortState)[keyof typeof PortState];
+export declare const InstanceSnapshotState: {
+  readonly Available: "available";
+  readonly Error: "error";
+  readonly Pending: "pending";
+};
+export type InstanceSnapshotState =
+  (typeof InstanceSnapshotState)[keyof typeof InstanceSnapshotState];
+export declare const LoadBalancerAttributeName: {
+  readonly HealthCheckPath: "HealthCheckPath";
+  readonly HttpsRedirectionEnabled: "HttpsRedirectionEnabled";
+  readonly SessionStickinessEnabled: "SessionStickinessEnabled";
+  readonly SessionStickiness_LB_CookieDurationSeconds: "SessionStickiness_LB_CookieDurationSeconds";
+  readonly TlsPolicyName: "TlsPolicyName";
+};
+export type LoadBalancerAttributeName =
+  (typeof LoadBalancerAttributeName)[keyof typeof LoadBalancerAttributeName];
+export declare const InstanceHealthState: {
+  readonly Draining: "draining";
+  readonly Healthy: "healthy";
+  readonly Initial: "initial";
+  readonly Unavailable: "unavailable";
+  readonly Unhealthy: "unhealthy";
+  readonly Unused: "unused";
+};
+export type InstanceHealthState =
+  (typeof InstanceHealthState)[keyof typeof InstanceHealthState];
+export declare const InstanceHealthReason: {
+  readonly InstanceDeregistrationInProgress: "Instance.DeregistrationInProgress";
+  readonly InstanceFailedHealthChecks: "Instance.FailedHealthChecks";
+  readonly InstanceInvalidState: "Instance.InvalidState";
+  readonly InstanceIpUnusable: "Instance.IpUnusable";
+  readonly InstanceNotInUse: "Instance.NotInUse";
+  readonly InstanceNotRegistered: "Instance.NotRegistered";
+  readonly InstanceResponseCodeMismatch: "Instance.ResponseCodeMismatch";
+  readonly InstanceTimeout: "Instance.Timeout";
+  readonly LbInitialHealthChecking: "Lb.InitialHealthChecking";
+  readonly LbInternalError: "Lb.InternalError";
+  readonly LbRegistrationInProgress: "Lb.RegistrationInProgress";
+};
+export type InstanceHealthReason =
+  (typeof InstanceHealthReason)[keyof typeof InstanceHealthReason];
+export declare const LoadBalancerProtocol: {
+  readonly HTTP: "HTTP";
+  readonly HTTP_HTTPS: "HTTP_HTTPS";
+};
+export type LoadBalancerProtocol =
+  (typeof LoadBalancerProtocol)[keyof typeof LoadBalancerProtocol];
+export declare const LoadBalancerState: {
+  readonly Active: "active";
+  readonly ActiveImpaired: "active_impaired";
+  readonly Failed: "failed";
+  readonly Provisioning: "provisioning";
+  readonly Unknown: "unknown";
+};
+export type LoadBalancerState =
+  (typeof LoadBalancerState)[keyof typeof LoadBalancerState];
+export declare const LoadBalancerMetricName: {
+  readonly ClientTLSNegotiationErrorCount: "ClientTLSNegotiationErrorCount";
+  readonly HTTPCode_Instance_2XX_Count: "HTTPCode_Instance_2XX_Count";
+  readonly HTTPCode_Instance_3XX_Count: "HTTPCode_Instance_3XX_Count";
+  readonly HTTPCode_Instance_4XX_Count: "HTTPCode_Instance_4XX_Count";
+  readonly HTTPCode_Instance_5XX_Count: "HTTPCode_Instance_5XX_Count";
+  readonly HTTPCode_LB_4XX_Count: "HTTPCode_LB_4XX_Count";
+  readonly HTTPCode_LB_5XX_Count: "HTTPCode_LB_5XX_Count";
+  readonly HealthyHostCount: "HealthyHostCount";
+  readonly InstanceResponseTime: "InstanceResponseTime";
+  readonly RejectedConnectionCount: "RejectedConnectionCount";
+  readonly RequestCount: "RequestCount";
+  readonly UnhealthyHostCount: "UnhealthyHostCount";
+};
+export type LoadBalancerMetricName =
+  (typeof LoadBalancerMetricName)[keyof typeof LoadBalancerMetricName];
+export declare const LoadBalancerTlsCertificateDnsRecordCreationStateCode: {
+  readonly Failed: "FAILED";
+  readonly Started: "STARTED";
+  readonly Succeeded: "SUCCEEDED";
+};
+export type LoadBalancerTlsCertificateDnsRecordCreationStateCode =
+  (typeof LoadBalancerTlsCertificateDnsRecordCreationStateCode)[keyof typeof LoadBalancerTlsCertificateDnsRecordCreationStateCode];
+export declare const LoadBalancerTlsCertificateDomainStatus: {
+  readonly Failed: "FAILED";
+  readonly PendingValidation: "PENDING_VALIDATION";
+  readonly Success: "SUCCESS";
+};
+export type LoadBalancerTlsCertificateDomainStatus =
+  (typeof LoadBalancerTlsCertificateDomainStatus)[keyof typeof LoadBalancerTlsCertificateDomainStatus];
+export declare const LoadBalancerTlsCertificateFailureReason: {
+  readonly AdditionalVerificationRequired: "ADDITIONAL_VERIFICATION_REQUIRED";
+  readonly DomainNotAllowed: "DOMAIN_NOT_ALLOWED";
+  readonly InvalidPublicDomain: "INVALID_PUBLIC_DOMAIN";
+  readonly NoAvailableContacts: "NO_AVAILABLE_CONTACTS";
+  readonly Other: "OTHER";
+};
+export type LoadBalancerTlsCertificateFailureReason =
+  (typeof LoadBalancerTlsCertificateFailureReason)[keyof typeof LoadBalancerTlsCertificateFailureReason];
+export declare const LoadBalancerTlsCertificateRenewalStatus: {
+  readonly Failed: "FAILED";
+  readonly PendingAutoRenewal: "PENDING_AUTO_RENEWAL";
+  readonly PendingValidation: "PENDING_VALIDATION";
+  readonly Success: "SUCCESS";
+};
+export type LoadBalancerTlsCertificateRenewalStatus =
+  (typeof LoadBalancerTlsCertificateRenewalStatus)[keyof typeof LoadBalancerTlsCertificateRenewalStatus];
+export declare const LoadBalancerTlsCertificateRevocationReason: {
+  readonly AACompromise: "A_A_COMPROMISE";
+  readonly AffiliationChanged: "AFFILIATION_CHANGED";
+  readonly CaCompromise: "CA_COMPROMISE";
+  readonly CertificateHold: "CERTIFICATE_HOLD";
+  readonly CessationOfOperation: "CESSATION_OF_OPERATION";
+  readonly KeyCompromise: "KEY_COMPROMISE";
+  readonly PrivilegeWithdrawn: "PRIVILEGE_WITHDRAWN";
+  readonly RemoveFromCrl: "REMOVE_FROM_CRL";
+  readonly Superceded: "SUPERCEDED";
+  readonly Unspecified: "UNSPECIFIED";
+};
+export type LoadBalancerTlsCertificateRevocationReason =
+  (typeof LoadBalancerTlsCertificateRevocationReason)[keyof typeof LoadBalancerTlsCertificateRevocationReason];
+export declare const LoadBalancerTlsCertificateStatus: {
+  readonly Expired: "EXPIRED";
+  readonly Failed: "FAILED";
+  readonly Inactive: "INACTIVE";
+  readonly Issued: "ISSUED";
+  readonly PendingValidation: "PENDING_VALIDATION";
+  readonly Revoked: "REVOKED";
+  readonly Unknown: "UNKNOWN";
+  readonly ValidationTimedOut: "VALIDATION_TIMED_OUT";
+};
+export type LoadBalancerTlsCertificateStatus =
+  (typeof LoadBalancerTlsCertificateStatus)[keyof typeof LoadBalancerTlsCertificateStatus];
+export declare const RelationalDatabaseEngine: {
+  readonly MYSQL: "mysql";
+};
+export type RelationalDatabaseEngine =
+  (typeof RelationalDatabaseEngine)[keyof typeof RelationalDatabaseEngine];
+export declare const RelationalDatabasePasswordVersion: {
+  readonly CURRENT: "CURRENT";
+  readonly PENDING: "PENDING";
+  readonly PREVIOUS: "PREVIOUS";
+};
+export type RelationalDatabasePasswordVersion =
+  (typeof RelationalDatabasePasswordVersion)[keyof typeof RelationalDatabasePasswordVersion];
+export declare const RelationalDatabaseMetricName: {
+  readonly CPUUtilization: "CPUUtilization";
+  readonly DatabaseConnections: "DatabaseConnections";
+  readonly DiskQueueDepth: "DiskQueueDepth";
+  readonly FreeStorageSpace: "FreeStorageSpace";
+  readonly NetworkReceiveThroughput: "NetworkReceiveThroughput";
+  readonly NetworkTransmitThroughput: "NetworkTransmitThroughput";
+};
+export type RelationalDatabaseMetricName =
+  (typeof RelationalDatabaseMetricName)[keyof typeof RelationalDatabaseMetricName];
+export declare const SetupStatus: {
+  readonly Failed: "failed";
+  readonly InProgress: "inProgress";
+  readonly Succeeded: "succeeded";
+};
+export type SetupStatus = (typeof SetupStatus)[keyof typeof SetupStatus];
+export declare const ResourceBucketAccess: {
+  readonly Allow: "allow";
+  readonly Deny: "deny";
+};
+export type ResourceBucketAccess =
+  (typeof ResourceBucketAccess)[keyof typeof ResourceBucketAccess];