@aws-sdk/client-lightsail 3.934.0 → 3.936.0

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

@@ -0,0 +1,1287 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const AccessDirection: {
+    readonly inbound: "inbound";
+    readonly outbound: "outbound";
+};
+/**
+ * @public
+ */
+export type AccessDirection = (typeof AccessDirection)[keyof typeof AccessDirection];
+/**
+ * @public
+ * @enum
+ */
+export declare const StatusType: {
+    readonly Active: "Active";
+    readonly Inactive: "Inactive";
+};
+/**
+ * @public
+ */
+export type StatusType = (typeof StatusType)[keyof typeof StatusType];
+/**
+ * @public
+ * @enum
+ */
+export declare const AccessType: {
+    readonly Private: "private";
+    readonly Public: "public";
+};
+/**
+ * @public
+ */
+export type AccessType = (typeof AccessType)[keyof typeof AccessType];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type BPAStatusMessage = (typeof BPAStatusMessage)[keyof typeof BPAStatusMessage];
+/**
+ * @public
+ * @enum
+ */
+export declare const AccountLevelBpaSyncStatus: {
+    readonly Defaulted: "Defaulted";
+    readonly Failed: "Failed";
+    readonly InSync: "InSync";
+    readonly NeverSynced: "NeverSynced";
+};
+/**
+ * @public
+ */
+export type AccountLevelBpaSyncStatus = (typeof AccountLevelBpaSyncStatus)[keyof typeof AccountLevelBpaSyncStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const AddOnType: {
+    readonly AutoSnapshot: "AutoSnapshot";
+    readonly StopInstanceOnIdle: "StopInstanceOnIdle";
+};
+/**
+ * @public
+ */
+export type AddOnType = (typeof AddOnType)[keyof typeof AddOnType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ComparisonOperator: {
+    readonly GreaterThanOrEqualToThreshold: "GreaterThanOrEqualToThreshold";
+    readonly GreaterThanThreshold: "GreaterThanThreshold";
+    readonly LessThanOrEqualToThreshold: "LessThanOrEqualToThreshold";
+    readonly LessThanThreshold: "LessThanThreshold";
+};
+/**
+ * @public
+ */
+export type ComparisonOperator = (typeof ComparisonOperator)[keyof typeof ComparisonOperator];
+/**
+ * @public
+ * @enum
+ */
+export declare const ContactProtocol: {
+    readonly Email: "Email";
+    readonly SMS: "SMS";
+};
+/**
+ * @public
+ */
+export type ContactProtocol = (typeof ContactProtocol)[keyof typeof ContactProtocol];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type RegionName = (typeof RegionName)[keyof typeof RegionName];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type MetricName = (typeof MetricName)[keyof typeof MetricName];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type ResourceType = (typeof ResourceType)[keyof typeof ResourceType];
+/**
+ * @public
+ * @enum
+ */
+export declare const AlarmState: {
+    readonly ALARM: "ALARM";
+    readonly INSUFFICIENT_DATA: "INSUFFICIENT_DATA";
+    readonly OK: "OK";
+};
+/**
+ * @public
+ */
+export type AlarmState = (typeof AlarmState)[keyof typeof AlarmState];
+/**
+ * @public
+ * @enum
+ */
+export declare const MetricStatistic: {
+    readonly Average: "Average";
+    readonly Maximum: "Maximum";
+    readonly Minimum: "Minimum";
+    readonly SampleCount: "SampleCount";
+    readonly Sum: "Sum";
+};
+/**
+ * @public
+ */
+export type MetricStatistic = (typeof MetricStatistic)[keyof typeof MetricStatistic];
+/**
+ * @public
+ * @enum
+ */
+export declare const TreatMissingData: {
+    readonly Breaching: "breaching";
+    readonly Ignore: "ignore";
+    readonly Missing: "missing";
+    readonly NotBreaching: "notBreaching";
+};
+/**
+ * @public
+ */
+export type TreatMissingData = (typeof TreatMissingData)[keyof typeof TreatMissingData];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type MetricUnit = (typeof MetricUnit)[keyof typeof MetricUnit];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type OperationType = (typeof OperationType)[keyof typeof OperationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const OperationStatus: {
+    readonly Completed: "Completed";
+    readonly Failed: "Failed";
+    readonly NotStarted: "NotStarted";
+    readonly Started: "Started";
+    readonly Succeeded: "Succeeded";
+};
+/**
+ * @public
+ */
+export type OperationStatus = (typeof OperationStatus)[keyof typeof OperationStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const AppCategory: {
+    readonly LfR: "LfR";
+};
+/**
+ * @public
+ */
+export type AppCategory = (typeof AppCategory)[keyof typeof AppCategory];
+/**
+ * @public
+ * @enum
+ */
+export declare const AutoMountStatus: {
+    readonly Failed: "Failed";
+    readonly Mounted: "Mounted";
+    readonly NotMounted: "NotMounted";
+    readonly Pending: "Pending";
+};
+/**
+ * @public
+ */
+export type AutoMountStatus = (typeof AutoMountStatus)[keyof typeof AutoMountStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const AutoSnapshotStatus: {
+    readonly FAILED: "Failed";
+    readonly IN_PROGRESS: "InProgress";
+    readonly NOT_FOUND: "NotFound";
+    readonly SUCCESS: "Success";
+};
+/**
+ * @public
+ */
+export type AutoSnapshotStatus = (typeof AutoSnapshotStatus)[keyof typeof AutoSnapshotStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const BehaviorEnum: {
+    readonly CacheSetting: "cache";
+    readonly DontCacheSetting: "dont-cache";
+};
+/**
+ * @public
+ */
+export type BehaviorEnum = (typeof BehaviorEnum)[keyof typeof BehaviorEnum];
+/**
+ * @public
+ * @enum
+ */
+export declare const InstancePlatform: {
+    readonly LinuxUnix: "LINUX_UNIX";
+    readonly Windows: "WINDOWS";
+};
+/**
+ * @public
+ */
+export type InstancePlatform = (typeof InstancePlatform)[keyof typeof InstancePlatform];
+/**
+ * @public
+ * @enum
+ */
+export declare const BlueprintType: {
+    readonly app: "app";
+    readonly os: "os";
+};
+/**
+ * @public
+ */
+export type BlueprintType = (typeof BlueprintType)[keyof typeof BlueprintType];
+/**
+ * @public
+ * @enum
+ */
+export declare const BucketMetricName: {
+    readonly BucketSizeBytes: "BucketSizeBytes";
+    readonly NumberOfObjects: "NumberOfObjects";
+};
+/**
+ * @public
+ */
+export type BucketMetricName = (typeof BucketMetricName)[keyof typeof BucketMetricName];
+/**
+ * @public
+ * @enum
+ */
+export declare const ForwardValues: {
+    readonly all: "all";
+    readonly allowList: "allow-list";
+    readonly none: "none";
+};
+/**
+ * @public
+ */
+export type ForwardValues = (typeof ForwardValues)[keyof typeof ForwardValues];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type HeaderEnum = (typeof HeaderEnum)[keyof typeof HeaderEnum];
+/**
+ * @public
+ * @enum
+ */
+export declare const DnsRecordCreationStateCode: {
+    readonly Failed: "FAILED";
+    readonly Started: "STARTED";
+    readonly Succeeded: "SUCCEEDED";
+};
+/**
+ * @public
+ */
+export type DnsRecordCreationStateCode = (typeof DnsRecordCreationStateCode)[keyof typeof DnsRecordCreationStateCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const CertificateDomainValidationStatus: {
+    readonly Failed: "FAILED";
+    readonly PendingValidation: "PENDING_VALIDATION";
+    readonly Success: "SUCCESS";
+};
+/**
+ * @public
+ */
+export type CertificateDomainValidationStatus = (typeof CertificateDomainValidationStatus)[keyof typeof CertificateDomainValidationStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const RenewalStatus: {
+    readonly Failed: "Failed";
+    readonly PendingAutoRenewal: "PendingAutoRenewal";
+    readonly PendingValidation: "PendingValidation";
+    readonly Success: "Success";
+};
+/**
+ * @public
+ */
+export type RenewalStatus = (typeof RenewalStatus)[keyof typeof RenewalStatus];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type CertificateStatus = (typeof CertificateStatus)[keyof typeof CertificateStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const CertificateProvider: {
+    readonly LetsEncrypt: "LetsEncrypt";
+};
+/**
+ * @public
+ */
+export type CertificateProvider = (typeof CertificateProvider)[keyof typeof CertificateProvider];
+/**
+ * @public
+ * @enum
+ */
+export declare const NetworkProtocol: {
+    readonly ALL: "all";
+    readonly ICMP: "icmp";
+    readonly ICMPV6: "icmpv6";
+    readonly TCP: "tcp";
+    readonly UDP: "udp";
+};
+/**
+ * @public
+ */
+export type NetworkProtocol = (typeof NetworkProtocol)[keyof typeof NetworkProtocol];
+/**
+ * @public
+ * @enum
+ */
+export declare const CloudFormationStackRecordSourceType: {
+    readonly ExportSnapshotRecord: "ExportSnapshotRecord";
+};
+/**
+ * @public
+ */
+export type CloudFormationStackRecordSourceType = (typeof CloudFormationStackRecordSourceType)[keyof typeof CloudFormationStackRecordSourceType];
+/**
+ * @public
+ * @enum
+ */
+export declare const RecordState: {
+    readonly Failed: "Failed";
+    readonly Started: "Started";
+    readonly Succeeded: "Succeeded";
+};
+/**
+ * @public
+ */
+export type RecordState = (typeof RecordState)[keyof typeof RecordState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ContactMethodStatus: {
+    readonly Invalid: "Invalid";
+    readonly PendingVerification: "PendingVerification";
+    readonly Valid: "Valid";
+};
+/**
+ * @public
+ */
+export type ContactMethodStatus = (typeof ContactMethodStatus)[keyof typeof ContactMethodStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ContactMethodVerificationProtocol: {
+    readonly Email: "Email";
+};
+/**
+ * @public
+ */
+export type ContactMethodVerificationProtocol = (typeof ContactMethodVerificationProtocol)[keyof typeof ContactMethodVerificationProtocol];
+/**
+ * @public
+ * @enum
+ */
+export declare const ContainerServiceProtocol: {
+    readonly HTTP: "HTTP";
+    readonly HTTPS: "HTTPS";
+    readonly TCP: "TCP";
+    readonly UDP: "UDP";
+};
+/**
+ * @public
+ */
+export type ContainerServiceProtocol = (typeof ContainerServiceProtocol)[keyof typeof ContainerServiceProtocol];
+/**
+ * @public
+ * @enum
+ */
+export declare const ContainerServiceDeploymentState: {
+    readonly ACTIVATING: "ACTIVATING";
+    readonly ACTIVE: "ACTIVE";
+    readonly FAILED: "FAILED";
+    readonly INACTIVE: "INACTIVE";
+};
+/**
+ * @public
+ */
+export type ContainerServiceDeploymentState = (typeof ContainerServiceDeploymentState)[keyof typeof ContainerServiceDeploymentState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ContainerServicePowerName: {
+    readonly large: "large";
+    readonly medium: "medium";
+    readonly micro: "micro";
+    readonly nano: "nano";
+    readonly small: "small";
+    readonly xlarge: "xlarge";
+};
+/**
+ * @public
+ */
+export type ContainerServicePowerName = (typeof ContainerServicePowerName)[keyof typeof ContainerServicePowerName];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type ContainerServiceState = (typeof ContainerServiceState)[keyof typeof ContainerServiceState];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type ContainerServiceStateDetailCode = (typeof ContainerServiceStateDetailCode)[keyof typeof ContainerServiceStateDetailCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const ContainerServiceMetricName: {
+    readonly CPUUtilization: "CPUUtilization";
+    readonly MemoryUtilization: "MemoryUtilization";
+};
+/**
+ * @public
+ */
+export type ContainerServiceMetricName = (typeof ContainerServiceMetricName)[keyof typeof ContainerServiceMetricName];
+/**
+ * @public
+ * @enum
+ */
+export declare const Currency: {
+    readonly USD: "USD";
+};
+/**
+ * @public
+ */
+export type Currency = (typeof Currency)[keyof typeof Currency];
+/**
+ * @public
+ * @enum
+ */
+export declare const PricingUnit: {
+    readonly Bundles: "Bundles";
+    readonly GB: "GB";
+    readonly GBMo: "GB-Mo";
+    readonly Hrs: "Hrs";
+    readonly Queries: "Queries";
+};
+/**
+ * @public
+ */
+export type PricingUnit = (typeof PricingUnit)[keyof typeof PricingUnit];
+/**
+ * @public
+ * @enum
+ */
+export declare const PortInfoSourceType: {
+    readonly Closed: "CLOSED";
+    readonly Default: "DEFAULT";
+    readonly Instance: "INSTANCE";
+    readonly None: "NONE";
+};
+/**
+ * @public
+ */
+export type PortInfoSourceType = (typeof PortInfoSourceType)[keyof typeof PortInfoSourceType];
+/**
+ * @public
+ * @enum
+ */
+export declare const IpAddressType: {
+    readonly DUALSTACK: "dualstack";
+    readonly IPV4: "ipv4";
+    readonly IPV6: "ipv6";
+};
+/**
+ * @public
+ */
+export type IpAddressType = (typeof IpAddressType)[keyof typeof IpAddressType];
+/**
+ * @public
+ * @enum
+ */
+export declare const OriginProtocolPolicyEnum: {
+    readonly HTTPOnly: "http-only";
+    readonly HTTPSOnly: "https-only";
+};
+/**
+ * @public
+ */
+export type OriginProtocolPolicyEnum = (typeof OriginProtocolPolicyEnum)[keyof typeof OriginProtocolPolicyEnum];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type ViewerMinimumTlsProtocolVersionEnum = (typeof ViewerMinimumTlsProtocolVersionEnum)[keyof typeof ViewerMinimumTlsProtocolVersionEnum];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type Status = (typeof Status)[keyof typeof Status];
+/**
+ * @public
+ * @enum
+ */
+export declare const DiskState: {
+    readonly Available: "available";
+    readonly Error: "error";
+    readonly InUse: "in-use";
+    readonly Pending: "pending";
+    readonly Unknown: "unknown";
+};
+/**
+ * @public
+ */
+export type DiskState = (typeof DiskState)[keyof typeof DiskState];
+/**
+ * @public
+ * @enum
+ */
+export declare const DiskSnapshotState: {
+    readonly Completed: "completed";
+    readonly Error: "error";
+    readonly Pending: "pending";
+    readonly Unknown: "unknown";
+};
+/**
+ * @public
+ */
+export type DiskSnapshotState = (typeof DiskSnapshotState)[keyof typeof DiskSnapshotState];
+/**
+ * @public
+ * @enum
+ */
+export declare const DistributionMetricName: {
+    readonly BytesDownloaded: "BytesDownloaded";
+    readonly BytesUploaded: "BytesUploaded";
+    readonly Http4xxErrorRate: "Http4xxErrorRate";
+    readonly Http5xxErrorRate: "Http5xxErrorRate";
+    readonly Requests: "Requests";
+    readonly TotalErrorRate: "TotalErrorRate";
+};
+/**
+ * @public
+ */
+export type DistributionMetricName = (typeof DistributionMetricName)[keyof typeof DistributionMetricName];
+/**
+ * @public
+ * @enum
+ */
+export declare const NameServersUpdateStateCode: {
+    readonly Failed: "FAILED";
+    readonly Pending: "PENDING";
+    readonly Started: "STARTED";
+    readonly Succeeded: "SUCCEEDED";
+};
+/**
+ * @public
+ */
+export type NameServersUpdateStateCode = (typeof NameServersUpdateStateCode)[keyof typeof NameServersUpdateStateCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const R53HostedZoneDeletionStateCode: {
+    readonly Failed: "FAILED";
+    readonly Pending: "PENDING";
+    readonly Started: "STARTED";
+    readonly Succeeded: "SUCCEEDED";
+};
+/**
+ * @public
+ */
+export type R53HostedZoneDeletionStateCode = (typeof R53HostedZoneDeletionStateCode)[keyof typeof R53HostedZoneDeletionStateCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExportSnapshotRecordSourceType: {
+    readonly DiskSnapshot: "DiskSnapshot";
+    readonly InstanceSnapshot: "InstanceSnapshot";
+};
+/**
+ * @public
+ */
+export type ExportSnapshotRecordSourceType = (typeof ExportSnapshotRecordSourceType)[keyof typeof ExportSnapshotRecordSourceType];
+/**
+ * @public
+ * @enum
+ */
+export declare const HttpEndpoint: {
+    readonly disabled: "disabled";
+    readonly enabled: "enabled";
+};
+/**
+ * @public
+ */
+export type HttpEndpoint = (typeof HttpEndpoint)[keyof typeof HttpEndpoint];
+/**
+ * @public
+ * @enum
+ */
+export declare const HttpProtocolIpv6: {
+    readonly disabled: "disabled";
+    readonly enabled: "enabled";
+};
+/**
+ * @public
+ */
+export type HttpProtocolIpv6 = (typeof HttpProtocolIpv6)[keyof typeof HttpProtocolIpv6];
+/**
+ * @public
+ * @enum
+ */
+export declare const HttpTokens: {
+    readonly optional: "optional";
+    readonly required: "required";
+};
+/**
+ * @public
+ */
+export type HttpTokens = (typeof HttpTokens)[keyof typeof HttpTokens];
+/**
+ * @public
+ * @enum
+ */
+export declare const InstanceMetadataState: {
+    readonly applied: "applied";
+    readonly pending: "pending";
+};
+/**
+ * @public
+ */
+export type InstanceMetadataState = (typeof InstanceMetadataState)[keyof typeof InstanceMetadataState];
+/**
+ * @public
+ * @enum
+ */
+export declare const PortAccessType: {
+    readonly Private: "Private";
+    readonly Public: "Public";
+};
+/**
+ * @public
+ */
+export type PortAccessType = (typeof PortAccessType)[keyof typeof PortAccessType];
+/**
+ * @public
+ * @enum
+ */
+export declare const InstanceAccessProtocol: {
+    readonly rdp: "rdp";
+    readonly ssh: "ssh";
+};
+/**
+ * @public
+ */
+export type InstanceAccessProtocol = (typeof InstanceAccessProtocol)[keyof typeof InstanceAccessProtocol];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type InstanceMetricName = (typeof InstanceMetricName)[keyof typeof InstanceMetricName];
+/**
+ * @public
+ * @enum
+ */
+export declare const PortState: {
+    readonly Closed: "closed";
+    readonly Open: "open";
+};
+/**
+ * @public
+ */
+export type PortState = (typeof PortState)[keyof typeof PortState];
+/**
+ * @public
+ * @enum
+ */
+export declare const InstanceSnapshotState: {
+    readonly Available: "available";
+    readonly Error: "error";
+    readonly Pending: "pending";
+};
+/**
+ * @public
+ */
+export type InstanceSnapshotState = (typeof InstanceSnapshotState)[keyof typeof InstanceSnapshotState];
+/**
+ * @public
+ * @enum
+ */
+export declare const LoadBalancerAttributeName: {
+    readonly HealthCheckPath: "HealthCheckPath";
+    readonly HttpsRedirectionEnabled: "HttpsRedirectionEnabled";
+    readonly SessionStickinessEnabled: "SessionStickinessEnabled";
+    readonly SessionStickiness_LB_CookieDurationSeconds: "SessionStickiness_LB_CookieDurationSeconds";
+    readonly TlsPolicyName: "TlsPolicyName";
+};
+/**
+ * @public
+ */
+export type LoadBalancerAttributeName = (typeof LoadBalancerAttributeName)[keyof typeof LoadBalancerAttributeName];
+/**
+ * @public
+ * @enum
+ */
+export declare const InstanceHealthState: {
+    readonly Draining: "draining";
+    readonly Healthy: "healthy";
+    readonly Initial: "initial";
+    readonly Unavailable: "unavailable";
+    readonly Unhealthy: "unhealthy";
+    readonly Unused: "unused";
+};
+/**
+ * @public
+ */
+export type InstanceHealthState = (typeof InstanceHealthState)[keyof typeof InstanceHealthState];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type InstanceHealthReason = (typeof InstanceHealthReason)[keyof typeof InstanceHealthReason];
+/**
+ * @public
+ * @enum
+ */
+export declare const LoadBalancerProtocol: {
+    readonly HTTP: "HTTP";
+    readonly HTTP_HTTPS: "HTTP_HTTPS";
+};
+/**
+ * @public
+ */
+export type LoadBalancerProtocol = (typeof LoadBalancerProtocol)[keyof typeof LoadBalancerProtocol];
+/**
+ * @public
+ * @enum
+ */
+export declare const LoadBalancerState: {
+    readonly Active: "active";
+    readonly ActiveImpaired: "active_impaired";
+    readonly Failed: "failed";
+    readonly Provisioning: "provisioning";
+    readonly Unknown: "unknown";
+};
+/**
+ * @public
+ */
+export type LoadBalancerState = (typeof LoadBalancerState)[keyof typeof LoadBalancerState];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type LoadBalancerMetricName = (typeof LoadBalancerMetricName)[keyof typeof LoadBalancerMetricName];
+/**
+ * @public
+ * @enum
+ */
+export declare const LoadBalancerTlsCertificateDnsRecordCreationStateCode: {
+    readonly Failed: "FAILED";
+    readonly Started: "STARTED";
+    readonly Succeeded: "SUCCEEDED";
+};
+/**
+ * @public
+ */
+export type LoadBalancerTlsCertificateDnsRecordCreationStateCode = (typeof LoadBalancerTlsCertificateDnsRecordCreationStateCode)[keyof typeof LoadBalancerTlsCertificateDnsRecordCreationStateCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const LoadBalancerTlsCertificateDomainStatus: {
+    readonly Failed: "FAILED";
+    readonly PendingValidation: "PENDING_VALIDATION";
+    readonly Success: "SUCCESS";
+};
+/**
+ * @public
+ */
+export type LoadBalancerTlsCertificateDomainStatus = (typeof LoadBalancerTlsCertificateDomainStatus)[keyof typeof LoadBalancerTlsCertificateDomainStatus];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type LoadBalancerTlsCertificateFailureReason = (typeof LoadBalancerTlsCertificateFailureReason)[keyof typeof LoadBalancerTlsCertificateFailureReason];
+/**
+ * @public
+ * @enum
+ */
+export declare const LoadBalancerTlsCertificateRenewalStatus: {
+    readonly Failed: "FAILED";
+    readonly PendingAutoRenewal: "PENDING_AUTO_RENEWAL";
+    readonly PendingValidation: "PENDING_VALIDATION";
+    readonly Success: "SUCCESS";
+};
+/**
+ * @public
+ */
+export type LoadBalancerTlsCertificateRenewalStatus = (typeof LoadBalancerTlsCertificateRenewalStatus)[keyof typeof LoadBalancerTlsCertificateRenewalStatus];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type LoadBalancerTlsCertificateRevocationReason = (typeof LoadBalancerTlsCertificateRevocationReason)[keyof typeof LoadBalancerTlsCertificateRevocationReason];
+/**
+ * @public
+ * @enum
+ */
+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";
+};
+/**
+ * @public
+ */
+export type LoadBalancerTlsCertificateStatus = (typeof LoadBalancerTlsCertificateStatus)[keyof typeof LoadBalancerTlsCertificateStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const RelationalDatabaseEngine: {
+    readonly MYSQL: "mysql";
+};
+/**
+ * @public
+ */
+export type RelationalDatabaseEngine = (typeof RelationalDatabaseEngine)[keyof typeof RelationalDatabaseEngine];
+/**
+ * @public
+ * @enum
+ */
+export declare const RelationalDatabasePasswordVersion: {
+    readonly CURRENT: "CURRENT";
+    readonly PENDING: "PENDING";
+    readonly PREVIOUS: "PREVIOUS";
+};
+/**
+ * @public
+ */
+export type RelationalDatabasePasswordVersion = (typeof RelationalDatabasePasswordVersion)[keyof typeof RelationalDatabasePasswordVersion];
+/**
+ * @public
+ * @enum
+ */
+export declare const RelationalDatabaseMetricName: {
+    readonly CPUUtilization: "CPUUtilization";
+    readonly DatabaseConnections: "DatabaseConnections";
+    readonly DiskQueueDepth: "DiskQueueDepth";
+    readonly FreeStorageSpace: "FreeStorageSpace";
+    readonly NetworkReceiveThroughput: "NetworkReceiveThroughput";
+    readonly NetworkTransmitThroughput: "NetworkTransmitThroughput";
+};
+/**
+ * @public
+ */
+export type RelationalDatabaseMetricName = (typeof RelationalDatabaseMetricName)[keyof typeof RelationalDatabaseMetricName];
+/**
+ * @public
+ * @enum
+ */
+export declare const SetupStatus: {
+    readonly Failed: "failed";
+    readonly InProgress: "inProgress";
+    readonly Succeeded: "succeeded";
+};
+/**
+ * @public
+ */
+export type SetupStatus = (typeof SetupStatus)[keyof typeof SetupStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ResourceBucketAccess: {
+    readonly Allow: "allow";
+    readonly Deny: "deny";
+};
+/**
+ * @public
+ */
+export type ResourceBucketAccess = (typeof ResourceBucketAccess)[keyof typeof ResourceBucketAccess];