@aws-sdk/client-lightsail 3.301.0 → 3.306.0

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

@@ -10,19 +10,22 @@ export declare class AccessDeniedException extends __BaseException {
     opts: __ExceptionOptionType<AccessDeniedException, __BaseException>
   );
 }
-export declare enum AccessDirection {
-  inbound = "inbound",
-  outbound = "outbound",
-}
+export declare const AccessDirection: {
+  readonly inbound: "inbound";
+  readonly outbound: "outbound";
+};
+export type AccessDirection =
+  (typeof AccessDirection)[keyof typeof AccessDirection];
 export interface AccessKeyLastUsed {
   lastUsedDate?: Date;
   region?: string;
   serviceName?: string;
 }
-export declare enum StatusType {
-  Active = "Active",
-  Inactive = "Inactive",
-}
+export declare const StatusType: {
+  readonly Active: "Active";
+  readonly Inactive: "Inactive";
+};
+export type StatusType = (typeof StatusType)[keyof typeof StatusType];
 export interface AccessKey {
   accessKeyId?: string;
   secretAccessKey?: string;
@@ -34,26 +37,31 @@ export interface ResourceReceivingAccess {
   name?: string;
   resourceType?: string;
 }
-export declare enum AccessType {
-  Private = "private",
-  Public = "public",
-}
+export declare const AccessType: {
+  readonly Private: "private";
+  readonly Public: "public";
+};
+export type AccessType = (typeof AccessType)[keyof typeof AccessType];
 export interface AccessRules {
   getObject?: AccessType | string;
   allowPublicOverrides?: boolean;
 }
-export declare enum BPAStatusMessage {
-  DEFAULTED_FOR_SLR_MISSING = "DEFAULTED_FOR_SLR_MISSING",
-  DEFAULTED_FOR_SLR_MISSING_ON_HOLD = "DEFAULTED_FOR_SLR_MISSING_ON_HOLD",
-  SYNC_ON_HOLD = "SYNC_ON_HOLD",
-  Unknown = "Unknown",
-}
-export declare enum AccountLevelBpaSyncStatus {
-  Defaulted = "Defaulted",
-  Failed = "Failed",
-  InSync = "InSync",
-  NeverSynced = "NeverSynced",
-}
+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 interface AccountLevelBpaSync {
   status?: AccountLevelBpaSyncStatus | string;
   lastSyncedAt?: Date;
@@ -81,10 +89,11 @@ export interface AddOn {
   threshold?: string;
   duration?: string;
 }
-export declare enum AddOnType {
-  AutoSnapshot = "AutoSnapshot",
-  StopInstanceOnIdle = "StopInstanceOnIdle",
-}
+export declare const AddOnType: {
+  readonly AutoSnapshot: "AutoSnapshot";
+  readonly StopInstanceOnIdle: "StopInstanceOnIdle";
+};
+export type AddOnType = (typeof AddOnType)[keyof typeof AddOnType];
 export interface AutoSnapshotAddOnRequest {
   snapshotTimeOfDay?: string;
 }
@@ -97,138 +106,151 @@ export interface AddOnRequest {
   autoSnapshotAddOnRequest?: AutoSnapshotAddOnRequest;
   stopInstanceOnIdleRequest?: StopInstanceOnIdleRequest;
 }
-export declare enum ComparisonOperator {
-  GreaterThanOrEqualToThreshold = "GreaterThanOrEqualToThreshold",
-  GreaterThanThreshold = "GreaterThanThreshold",
-  LessThanOrEqualToThreshold = "LessThanOrEqualToThreshold",
-  LessThanThreshold = "LessThanThreshold",
-}
-export declare enum ContactProtocol {
-  Email = "Email",
-  SMS = "SMS",
-}
-export declare enum RegionName {
-  AP_NORTHEAST_1 = "ap-northeast-1",
-  AP_NORTHEAST_2 = "ap-northeast-2",
-  AP_SOUTHEAST_1 = "ap-southeast-1",
-  AP_SOUTHEAST_2 = "ap-southeast-2",
-  AP_SOUTH_1 = "ap-south-1",
-  CA_CENTRAL_1 = "ca-central-1",
-  EU_CENTRAL_1 = "eu-central-1",
-  EU_NORTH_1 = "eu-north-1",
-  EU_WEST_1 = "eu-west-1",
-  EU_WEST_2 = "eu-west-2",
-  EU_WEST_3 = "eu-west-3",
-  US_EAST_1 = "us-east-1",
-  US_EAST_2 = "us-east-2",
-  US_WEST_1 = "us-west-1",
-  US_WEST_2 = "us-west-2",
-}
+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_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 interface ResourceLocation {
   availabilityZone?: string;
   regionName?: RegionName | string;
 }
-export declare enum MetricName {
-  BurstCapacityPercentage = "BurstCapacityPercentage",
-  BurstCapacityTime = "BurstCapacityTime",
-  CPUUtilization = "CPUUtilization",
-  ClientTLSNegotiationErrorCount = "ClientTLSNegotiationErrorCount",
-  DatabaseConnections = "DatabaseConnections",
-  DiskQueueDepth = "DiskQueueDepth",
-  FreeStorageSpace = "FreeStorageSpace",
-  HTTPCode_Instance_2XX_Count = "HTTPCode_Instance_2XX_Count",
-  HTTPCode_Instance_3XX_Count = "HTTPCode_Instance_3XX_Count",
-  HTTPCode_Instance_4XX_Count = "HTTPCode_Instance_4XX_Count",
-  HTTPCode_Instance_5XX_Count = "HTTPCode_Instance_5XX_Count",
-  HTTPCode_LB_4XX_Count = "HTTPCode_LB_4XX_Count",
-  HTTPCode_LB_5XX_Count = "HTTPCode_LB_5XX_Count",
-  HealthyHostCount = "HealthyHostCount",
-  InstanceResponseTime = "InstanceResponseTime",
-  NetworkIn = "NetworkIn",
-  NetworkOut = "NetworkOut",
-  NetworkReceiveThroughput = "NetworkReceiveThroughput",
-  NetworkTransmitThroughput = "NetworkTransmitThroughput",
-  RejectedConnectionCount = "RejectedConnectionCount",
-  RequestCount = "RequestCount",
-  StatusCheckFailed = "StatusCheckFailed",
-  StatusCheckFailed_Instance = "StatusCheckFailed_Instance",
-  StatusCheckFailed_System = "StatusCheckFailed_System",
-  UnhealthyHostCount = "UnhealthyHostCount",
-}
-export declare enum ResourceType {
-  Alarm = "Alarm",
-  Bucket = "Bucket",
-  Certificate = "Certificate",
-  CloudFormationStackRecord = "CloudFormationStackRecord",
-  ContactMethod = "ContactMethod",
-  ContainerService = "ContainerService",
-  Disk = "Disk",
-  DiskSnapshot = "DiskSnapshot",
-  Distribution = "Distribution",
-  Domain = "Domain",
-  ExportSnapshotRecord = "ExportSnapshotRecord",
-  Instance = "Instance",
-  InstanceSnapshot = "InstanceSnapshot",
-  KeyPair = "KeyPair",
-  LoadBalancer = "LoadBalancer",
-  LoadBalancerTlsCertificate = "LoadBalancerTlsCertificate",
-  PeeredVpc = "PeeredVpc",
-  RelationalDatabase = "RelationalDatabase",
-  RelationalDatabaseSnapshot = "RelationalDatabaseSnapshot",
-  StaticIp = "StaticIp",
-}
+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 interface MonitoredResourceInfo {
   arn?: string;
   name?: string;
   resourceType?: ResourceType | string;
 }
-export declare enum AlarmState {
-  ALARM = "ALARM",
-  INSUFFICIENT_DATA = "INSUFFICIENT_DATA",
-  OK = "OK",
-}
-export declare enum MetricStatistic {
-  Average = "Average",
-  Maximum = "Maximum",
-  Minimum = "Minimum",
-  SampleCount = "SampleCount",
-  Sum = "Sum",
-}
-export declare enum TreatMissingData {
-  Breaching = "breaching",
-  Ignore = "ignore",
-  Missing = "missing",
-  NotBreaching = "notBreaching",
-}
-export declare enum MetricUnit {
-  Bits = "Bits",
-  BitsSecond = "Bits/Second",
-  Bytes = "Bytes",
-  BytesSecond = "Bytes/Second",
-  Count = "Count",
-  CountSecond = "Count/Second",
-  Gigabits = "Gigabits",
-  GigabitsSecond = "Gigabits/Second",
-  Gigabytes = "Gigabytes",
-  GigabytesSecond = "Gigabytes/Second",
-  Kilobits = "Kilobits",
-  KilobitsSecond = "Kilobits/Second",
-  Kilobytes = "Kilobytes",
-  KilobytesSecond = "Kilobytes/Second",
-  Megabits = "Megabits",
-  MegabitsSecond = "Megabits/Second",
-  Megabytes = "Megabytes",
-  MegabytesSecond = "Megabytes/Second",
-  Microseconds = "Microseconds",
-  Milliseconds = "Milliseconds",
-  None = "None",
-  Percent = "Percent",
-  Seconds = "Seconds",
-  Terabits = "Terabits",
-  TerabitsSecond = "Terabits/Second",
-  Terabytes = "Terabytes",
-  TerabytesSecond = "Terabytes/Second",
-}
+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 interface Alarm {
   name?: string;
   arn?: string;
@@ -254,97 +276,100 @@ export interface Alarm {
 export interface AllocateStaticIpRequest {
   staticIpName: string | undefined;
 }
-export declare enum OperationType {
-  AllocateStaticIp = "AllocateStaticIp",
-  AttachCertificateToDistribution = "AttachCertificateToDistribution",
-  AttachDisk = "AttachDisk",
-  AttachInstancesToLoadBalancer = "AttachInstancesToLoadBalancer",
-  AttachLoadBalancerTlsCertificate = "AttachLoadBalancerTlsCertificate",
-  AttachStaticIp = "AttachStaticIp",
-  CloseInstancePublicPorts = "CloseInstancePublicPorts",
-  CreateBucket = "CreateBucket",
-  CreateBucketAccessKey = "CreateBucketAccessKey",
-  CreateCertificate = "CreateCertificate",
-  CreateContactMethod = "CreateContactMethod",
-  CreateContainerService = "CreateContainerService",
-  CreateContainerServiceDeployment = "CreateContainerServiceDeployment",
-  CreateContainerServiceRegistryLogin = "CreateContainerServiceRegistryLogin",
-  CreateDisk = "CreateDisk",
-  CreateDiskFromSnapshot = "CreateDiskFromSnapshot",
-  CreateDiskSnapshot = "CreateDiskSnapshot",
-  CreateDistribution = "CreateDistribution",
-  CreateDomain = "CreateDomain",
-  CreateInstance = "CreateInstance",
-  CreateInstanceSnapshot = "CreateInstanceSnapshot",
-  CreateInstancesFromSnapshot = "CreateInstancesFromSnapshot",
-  CreateLoadBalancer = "CreateLoadBalancer",
-  CreateLoadBalancerTlsCertificate = "CreateLoadBalancerTlsCertificate",
-  CreateRelationalDatabase = "CreateRelationalDatabase",
-  CreateRelationalDatabaseFromSnapshot = "CreateRelationalDatabaseFromSnapshot",
-  CreateRelationalDatabaseSnapshot = "CreateRelationalDatabaseSnapshot",
-  DeleteAlarm = "DeleteAlarm",
-  DeleteBucket = "DeleteBucket",
-  DeleteBucketAccessKey = "DeleteBucketAccessKey",
-  DeleteCertificate = "DeleteCertificate",
-  DeleteContactMethod = "DeleteContactMethod",
-  DeleteContainerImage = "DeleteContainerImage",
-  DeleteContainerService = "DeleteContainerService",
-  DeleteDisk = "DeleteDisk",
-  DeleteDiskSnapshot = "DeleteDiskSnapshot",
-  DeleteDistribution = "DeleteDistribution",
-  DeleteDomain = "DeleteDomain",
-  DeleteDomainEntry = "DeleteDomainEntry",
-  DeleteInstance = "DeleteInstance",
-  DeleteInstanceSnapshot = "DeleteInstanceSnapshot",
-  DeleteKnownHostKeys = "DeleteKnownHostKeys",
-  DeleteLoadBalancer = "DeleteLoadBalancer",
-  DeleteLoadBalancerTlsCertificate = "DeleteLoadBalancerTlsCertificate",
-  DeleteRelationalDatabase = "DeleteRelationalDatabase",
-  DeleteRelationalDatabaseSnapshot = "DeleteRelationalDatabaseSnapshot",
-  DetachCertificateFromDistribution = "DetachCertificateFromDistribution",
-  DetachDisk = "DetachDisk",
-  DetachInstancesFromLoadBalancer = "DetachInstancesFromLoadBalancer",
-  DetachStaticIp = "DetachStaticIp",
-  DisableAddOn = "DisableAddOn",
-  EnableAddOn = "EnableAddOn",
-  GetAlarms = "GetAlarms",
-  GetContactMethods = "GetContactMethods",
-  OpenInstancePublicPorts = "OpenInstancePublicPorts",
-  PutAlarm = "PutAlarm",
-  PutInstancePublicPorts = "PutInstancePublicPorts",
-  RebootInstance = "RebootInstance",
-  RebootRelationalDatabase = "RebootRelationalDatabase",
-  RegisterContainerImage = "RegisterContainerImage",
-  ReleaseStaticIp = "ReleaseStaticIp",
-  ResetDistributionCache = "ResetDistributionCache",
-  SendContactMethodVerification = "SendContactMethodVerification",
-  SetIpAddressType = "SetIpAddressType",
-  SetResourceAccessForBucket = "SetResourceAccessForBucket",
-  StartGUISession = "StartGUISession",
-  StartInstance = "StartInstance",
-  StartRelationalDatabase = "StartRelationalDatabase",
-  StopGUISession = "StopGUISession",
-  StopInstance = "StopInstance",
-  StopRelationalDatabase = "StopRelationalDatabase",
-  TestAlarm = "TestAlarm",
-  UpdateBucket = "UpdateBucket",
-  UpdateBucketBundle = "UpdateBucketBundle",
-  UpdateContainerService = "UpdateContainerService",
-  UpdateDistribution = "UpdateDistribution",
-  UpdateDistributionBundle = "UpdateDistributionBundle",
-  UpdateDomainEntry = "UpdateDomainEntry",
-  UpdateInstanceMetadataOptions = "UpdateInstanceMetadataOptions",
-  UpdateLoadBalancerAttribute = "UpdateLoadBalancerAttribute",
-  UpdateRelationalDatabase = "UpdateRelationalDatabase",
-  UpdateRelationalDatabaseParameters = "UpdateRelationalDatabaseParameters",
-}
-export declare enum OperationStatus {
-  Completed = "Completed",
-  Failed = "Failed",
-  NotStarted = "NotStarted",
-  Started = "Started",
-  Succeeded = "Succeeded",
-}
+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 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 interface Operation {
   id?: string;
   resourceName?: string;
@@ -408,9 +433,10 @@ export declare class UnauthenticatedException extends __BaseException {
     opts: __ExceptionOptionType<UnauthenticatedException, __BaseException>
   );
 }
-export declare enum AppCategory {
-  LfR = "LfR",
-}
+export declare const AppCategory: {
+  readonly LfR: "LfR";
+};
+export type AppCategory = (typeof AppCategory)[keyof typeof AppCategory];
 export interface AttachCertificateToDistributionRequest {
   distributionName: string | undefined;
   certificateName: string | undefined;
@@ -456,18 +482,22 @@ export interface AttachStaticIpRequest {
 export interface AttachStaticIpResult {
   operations?: Operation[];
 }
-export declare enum AutoMountStatus {
-  Failed = "Failed",
-  Mounted = "Mounted",
-  NotMounted = "NotMounted",
-  Pending = "Pending",
-}
-export declare enum AutoSnapshotStatus {
-  FAILED = "Failed",
-  IN_PROGRESS = "InProgress",
-  NOT_FOUND = "NotFound",
-  SUCCESS = "Success",
-}
+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 interface AutoSnapshotDetails {
   date?: string;
   createdAt?: Date;
@@ -478,18 +508,22 @@ export interface AvailabilityZone {
   zoneName?: string;
   state?: string;
 }
-export declare enum BehaviorEnum {
-  CacheSetting = "cache",
-  DontCacheSetting = "dont-cache",
-}
-export declare enum InstancePlatform {
-  LinuxUnix = "LINUX_UNIX",
-  Windows = "WINDOWS",
-}
-export declare enum BlueprintType {
-  app = "app",
-  os = "os",
-}
+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 interface Blueprint {
   blueprintId?: string;
   name?: string;
@@ -544,10 +578,12 @@ export interface BucketBundle {
   transferPerMonthInGb?: number;
   isActive?: boolean;
 }
-export declare enum BucketMetricName {
-  BucketSizeBytes = "BucketSizeBytes",
-  NumberOfObjects = "NumberOfObjects",
-}
+export declare const BucketMetricName: {
+  readonly BucketSizeBytes: "BucketSizeBytes";
+  readonly NumberOfObjects: "NumberOfObjects";
+};
+export type BucketMetricName =
+  (typeof BucketMetricName)[keyof typeof BucketMetricName];
 export interface Bundle {
   price?: number;
   cpuCount?: number;
@@ -569,32 +605,34 @@ export interface CacheBehaviorPerPath {
   path?: string;
   behavior?: BehaviorEnum | string;
 }
-export declare enum ForwardValues {
-  all = "all",
-  allowList = "allow-list",
-  none = "none",
-}
+export declare const ForwardValues: {
+  readonly all: "all";
+  readonly allowList: "allow-list";
+  readonly none: "none";
+};
+export type ForwardValues = (typeof ForwardValues)[keyof typeof ForwardValues];
 export interface CookieObject {
   option?: ForwardValues | string;
   cookiesAllowList?: string[];
 }
-export declare enum HeaderEnum {
-  accept = "Accept",
-  acceptCharset = "Accept-Charset",
-  acceptDatetime = "Accept-Datetime",
-  acceptEncoding = "Accept-Encoding",
-  acceptLanguage = "Accept-Language",
-  authorization = "Authorization",
-  cloudFrontForwardedProto = "CloudFront-Forwarded-Proto",
-  cloudFrontIsDesktopViewer = "CloudFront-Is-Desktop-Viewer",
-  cloudFrontIsMobileViewer = "CloudFront-Is-Mobile-Viewer",
-  cloudFrontIsSmartTVViewer = "CloudFront-Is-SmartTV-Viewer",
-  cloudFrontIsTabletViewer = "CloudFront-Is-Tablet-Viewer",
-  cloudFrontViewerCountry = "CloudFront-Viewer-Country",
-  host = "Host",
-  origin = "Origin",
-  referer = "Referer",
-}
+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 interface HeaderObject {
   option?: ForwardValues | string;
   headersAllowList?: (HeaderEnum | string)[];
@@ -613,11 +651,13 @@ export interface CacheSettings {
   forwardedHeaders?: HeaderObject;
   forwardedQueryStrings?: QueryStringObject;
 }
-export declare enum DnsRecordCreationStateCode {
-  Failed = "FAILED",
-  Started = "STARTED",
-  Succeeded = "SUCCEEDED",
-}
+export declare const DnsRecordCreationStateCode: {
+  readonly Failed: "FAILED";
+  readonly Started: "STARTED";
+  readonly Succeeded: "SUCCEEDED";
+};
+export type DnsRecordCreationStateCode =
+  (typeof DnsRecordCreationStateCode)[keyof typeof DnsRecordCreationStateCode];
 export interface DnsRecordCreationState {
   code?: DnsRecordCreationStateCode | string;
   message?: string;
@@ -627,38 +667,43 @@ export interface ResourceRecord {
   type?: string;
   value?: string;
 }
-export declare enum CertificateDomainValidationStatus {
-  Failed = "FAILED",
-  PendingValidation = "PENDING_VALIDATION",
-  Success = "SUCCESS",
-}
+export declare const CertificateDomainValidationStatus: {
+  readonly Failed: "FAILED";
+  readonly PendingValidation: "PENDING_VALIDATION";
+  readonly Success: "SUCCESS";
+};
+export type CertificateDomainValidationStatus =
+  (typeof CertificateDomainValidationStatus)[keyof typeof CertificateDomainValidationStatus];
 export interface DomainValidationRecord {
   domainName?: string;
   resourceRecord?: ResourceRecord;
   dnsRecordCreationState?: DnsRecordCreationState;
   validationStatus?: CertificateDomainValidationStatus | string;
 }
-export declare enum RenewalStatus {
-  Failed = "Failed",
-  PendingAutoRenewal = "PendingAutoRenewal",
-  PendingValidation = "PendingValidation",
-  Success = "Success",
-}
+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 interface RenewalSummary {
   domainValidationRecords?: DomainValidationRecord[];
   renewalStatus?: RenewalStatus | string;
   renewalStatusReason?: string;
   updatedAt?: Date;
 }
-export declare enum CertificateStatus {
-  Expired = "EXPIRED",
-  Failed = "FAILED",
-  Inactive = "INACTIVE",
-  Issued = "ISSUED",
-  PendingValidation = "PENDING_VALIDATION",
-  Revoked = "REVOKED",
-  ValidationTimedOut = "VALIDATION_TIMED_OUT",
-}
+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 interface Certificate {
   arn?: string;
   name?: string;
@@ -689,12 +734,14 @@ export interface CertificateSummary {
   certificateDetail?: Certificate;
   tags?: Tag[];
 }
-export declare enum NetworkProtocol {
-  ALL = "all",
-  ICMP = "icmp",
-  TCP = "tcp",
-  UDP = "udp",
-}
+export declare const NetworkProtocol: {
+  readonly ALL: "all";
+  readonly ICMP: "icmp";
+  readonly TCP: "tcp";
+  readonly UDP: "udp";
+};
+export type NetworkProtocol =
+  (typeof NetworkProtocol)[keyof typeof NetworkProtocol];
 export interface PortInfo {
   fromPort?: number;
   toPort?: number;
@@ -714,19 +761,22 @@ export interface DestinationInfo {
   id?: string;
   service?: string;
 }
-export declare enum CloudFormationStackRecordSourceType {
-  ExportSnapshotRecord = "ExportSnapshotRecord",
-}
+export declare const CloudFormationStackRecordSourceType: {
+  readonly ExportSnapshotRecord: "ExportSnapshotRecord";
+};
+export type CloudFormationStackRecordSourceType =
+  (typeof CloudFormationStackRecordSourceType)[keyof typeof CloudFormationStackRecordSourceType];
 export interface CloudFormationStackRecordSourceInfo {
   resourceType?: CloudFormationStackRecordSourceType | string;
   name?: string;
   arn?: string;
 }
-export declare enum RecordState {
-  Failed = "Failed",
-  Started = "Started",
-  Succeeded = "Succeeded",
-}
+export declare const RecordState: {
+  readonly Failed: "Failed";
+  readonly Started: "Started";
+  readonly Succeeded: "Succeeded";
+};
+export type RecordState = (typeof RecordState)[keyof typeof RecordState];
 export interface CloudFormationStackRecord {
   name?: string;
   arn?: string;
@@ -737,11 +787,13 @@ export interface CloudFormationStackRecord {
   sourceInfo?: CloudFormationStackRecordSourceInfo[];
   destinationInfo?: DestinationInfo;
 }
-export declare enum ContactMethodStatus {
-  Invalid = "Invalid",
-  PendingVerification = "PendingVerification",
-  Valid = "Valid",
-}
+export declare const ContactMethodStatus: {
+  readonly Invalid: "Invalid";
+  readonly PendingVerification: "PendingVerification";
+  readonly Valid: "Valid";
+};
+export type ContactMethodStatus =
+  (typeof ContactMethodStatus)[keyof typeof ContactMethodStatus];
 export interface ContactMethod {
   contactEndpoint?: string;
   status?: ContactMethodStatus | string;
@@ -753,15 +805,19 @@ export interface ContactMethod {
   resourceType?: ResourceType | string;
   supportCode?: string;
 }
-export declare enum ContactMethodVerificationProtocol {
-  Email = "Email",
-}
-export declare enum ContainerServiceProtocol {
-  HTTP = "HTTP",
-  HTTPS = "HTTPS",
-  TCP = "TCP",
-  UDP = "UDP",
-}
+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 interface Container {
   image?: string;
   command?: string[];
@@ -786,12 +842,14 @@ export interface ContainerServiceEndpoint {
   containerPort?: number;
   healthCheck?: ContainerServiceHealthCheckConfig;
 }
-export declare enum ContainerServiceDeploymentState {
-  ACTIVATING = "ACTIVATING",
-  ACTIVE = "ACTIVE",
-  FAILED = "FAILED",
-  INACTIVE = "INACTIVE",
-}
+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 interface ContainerServiceDeployment {
   version?: number;
   state?: ContainerServiceDeploymentState | string;
@@ -799,14 +857,16 @@ export interface ContainerServiceDeployment {
   publicEndpoint?: ContainerServiceEndpoint;
   createdAt?: Date;
 }
-export declare enum ContainerServicePowerName {
-  large = "large",
-  medium = "medium",
-  micro = "micro",
-  nano = "nano",
-  small = "small",
-  xlarge = "xlarge",
-}
+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 interface ContainerServiceECRImagePullerRole {
   isActive?: boolean;
   principalArn?: string;
@@ -814,26 +874,30 @@ export interface ContainerServiceECRImagePullerRole {
 export interface PrivateRegistryAccess {
   ecrImagePullerRole?: ContainerServiceECRImagePullerRole;
 }
-export declare enum ContainerServiceState {
-  DELETING = "DELETING",
-  DEPLOYING = "DEPLOYING",
-  DISABLED = "DISABLED",
-  PENDING = "PENDING",
-  READY = "READY",
-  RUNNING = "RUNNING",
-  UPDATING = "UPDATING",
-}
-export declare enum ContainerServiceStateDetailCode {
-  ACTIVATING_DEPLOYMENT = "ACTIVATING_DEPLOYMENT",
-  CERTIFICATE_LIMIT_EXCEEDED = "CERTIFICATE_LIMIT_EXCEEDED",
-  CREATING_DEPLOYMENT = "CREATING_DEPLOYMENT",
-  CREATING_NETWORK_INFRASTRUCTURE = "CREATING_NETWORK_INFRASTRUCTURE",
-  CREATING_SYSTEM_RESOURCES = "CREATING_SYSTEM_RESOURCES",
-  EVALUATING_HEALTH_CHECK = "EVALUATING_HEALTH_CHECK",
-  PROVISIONING_CERTIFICATE = "PROVISIONING_CERTIFICATE",
-  PROVISIONING_SERVICE = "PROVISIONING_SERVICE",
-  UNKNOWN_ERROR = "UNKNOWN_ERROR",
-}
+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 interface ContainerServiceStateDetail {
   code?: ContainerServiceStateDetailCode | string;
   message?: string;
@@ -875,10 +939,12 @@ export interface ContainerServiceLogEvent {
   createdAt?: Date;
   message?: string;
 }
-export declare enum ContainerServiceMetricName {
-  CPUUtilization = "CPUUtilization",
-  MemoryUtilization = "MemoryUtilization",
-}
+export declare const ContainerServiceMetricName: {
+  readonly CPUUtilization: "CPUUtilization";
+  readonly MemoryUtilization: "MemoryUtilization";
+};
+export type ContainerServiceMetricName =
+  (typeof ContainerServiceMetricName)[keyof typeof ContainerServiceMetricName];
 export interface ContainerServicePower {
   powerId?: string;
   price?: number;
@@ -907,16 +973,18 @@ export interface CopySnapshotRequest {
 export interface CopySnapshotResult {
   operations?: Operation[];
 }
-export declare enum Currency {
-  USD = "USD",
-}
-export declare enum PricingUnit {
-  Bundles = "Bundles",
-  GB = "GB",
-  GBMo = "GB-Mo",
-  Hrs = "Hrs",
-  Queries = "Queries",
-}
+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 interface TimePeriod {
   start?: Date;
   end?: Date;
@@ -959,12 +1027,14 @@ export interface CreateCertificateResult {
   certificate?: CertificateSummary;
   operations?: Operation[];
 }
-export declare enum PortInfoSourceType {
-  Closed = "CLOSED",
-  Default = "DEFAULT",
-  Instance = "INSTANCE",
-  None = "NONE",
-}
+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 interface InstanceEntry {
   sourceName: string | undefined;
   instanceType: string | undefined;
@@ -1045,14 +1115,17 @@ export interface CreateDiskSnapshotRequest {
 export interface CreateDiskSnapshotResult {
   operations?: Operation[];
 }
-export declare enum IpAddressType {
-  DUALSTACK = "dualstack",
-  IPV4 = "ipv4",
-}
-export declare enum OriginProtocolPolicyEnum {
-  HTTPOnly = "http-only",
-  HTTPSOnly = "https-only",
-}
+export declare const IpAddressType: {
+  readonly DUALSTACK: "dualstack";
+  readonly IPV4: "ipv4";
+};
+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 interface InputOrigin {
   name?: string;
   regionName?: RegionName | string;
@@ -1130,18 +1203,19 @@ export interface Session {
   url?: string;
   isPrimary?: boolean;
 }
-export declare enum Status {
-  FailedInstanceCreation = "failedInstanceCreation",
-  FailedStartingGUISession = "failedStartingGUISession",
-  FailedStoppingGUISession = "failedStoppingGUISession",
-  NotStarted = "notStarted",
-  SettingUpInstance = "settingUpInstance",
-  StartExpired = "startExpired",
-  Started = "started",
-  Starting = "starting",
-  Stopped = "stopped",
-  Stopping = "stopping",
-}
+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 interface CreateGUISessionAccessDetailsResult {
   resourceName?: string;
   status?: Status | string;
@@ -1438,13 +1512,14 @@ export interface DisableAddOnRequest {
 export interface DisableAddOnResult {
   operations?: Operation[];
 }
-export declare enum DiskState {
-  Available = "available",
-  Error = "error",
-  InUse = "in-use",
-  Pending = "pending",
-  Unknown = "unknown",
-}
+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 interface Disk {
   name?: string;
   arn?: string;
@@ -1471,12 +1546,14 @@ export interface DiskInfo {
   sizeInGb?: number;
   isSystemDisk?: boolean;
 }
-export declare enum DiskSnapshotState {
-  Completed = "completed",
-  Error = "error",
-  Pending = "pending",
-  Unknown = "unknown",
-}
+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 interface DiskSnapshot {
   name?: string;
   arn?: string;
@@ -1504,30 +1581,36 @@ export interface DistributionBundle {
   transferPerMonthInGb?: number;
   isActive?: boolean;
 }
-export declare enum DistributionMetricName {
-  BytesDownloaded = "BytesDownloaded",
-  BytesUploaded = "BytesUploaded",
-  Http4xxErrorRate = "Http4xxErrorRate",
-  Http5xxErrorRate = "Http5xxErrorRate",
-  Requests = "Requests",
-  TotalErrorRate = "TotalErrorRate",
-}
-export declare enum NameServersUpdateStateCode {
-  Failed = "FAILED",
-  Pending = "PENDING",
-  Started = "STARTED",
-  Succeeded = "SUCCEEDED",
-}
+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 interface NameServersUpdateState {
   code?: NameServersUpdateStateCode | string;
   message?: string;
 }
-export declare enum R53HostedZoneDeletionStateCode {
-  Failed = "FAILED",
-  Pending = "PENDING",
-  Started = "STARTED",
-  Succeeded = "SUCCEEDED",
-}
+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 interface R53HostedZoneDeletionState {
   code?: R53HostedZoneDeletionStateCode | string;
   message?: string;
@@ -1571,10 +1654,12 @@ export interface InstanceSnapshotInfo {
   fromBlueprintId?: string;
   fromDiskInfo?: DiskInfo[];
 }
-export declare enum ExportSnapshotRecordSourceType {
-  DiskSnapshot = "DiskSnapshot",
-  InstanceSnapshot = "InstanceSnapshot",
-}
+export declare const ExportSnapshotRecordSourceType: {
+  readonly DiskSnapshot: "DiskSnapshot";
+  readonly InstanceSnapshot: "InstanceSnapshot";
+};
+export type ExportSnapshotRecordSourceType =
+  (typeof ExportSnapshotRecordSourceType)[keyof typeof ExportSnapshotRecordSourceType];
 export interface ExportSnapshotRecordSourceInfo {
   resourceType?: ExportSnapshotRecordSourceType | string;
   createdAt?: Date;