@aws-sdk/client-ec2 3.301.0 → 3.303.0

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

@@ -30,11 +30,13 @@ import {
   VpcIpv6CidrBlockAssociation,
   WeekDay,
 } from "./models_0";
-export declare enum ClientVpnAuthenticationType {
-  certificate_authentication = "certificate-authentication",
-  directory_service_authentication = "directory-service-authentication",
-  federated_authentication = "federated-authentication",
-}
+export declare const ClientVpnAuthenticationType: {
+  readonly certificate_authentication: "certificate-authentication";
+  readonly directory_service_authentication: "directory-service-authentication";
+  readonly federated_authentication: "federated-authentication";
+};
+export type ClientVpnAuthenticationType =
+  (typeof ClientVpnAuthenticationType)[keyof typeof ClientVpnAuthenticationType];
 export interface ClientVpnAuthenticationRequest {
   Type?: ClientVpnAuthenticationType | string;
   ActiveDirectory?: DirectoryServiceAuthenticationRequest;
@@ -54,14 +56,18 @@ export interface ConnectionLogOptions {
   CloudwatchLogGroup?: string;
   CloudwatchLogStream?: string;
 }
-export declare enum SelfServicePortal {
-  disabled = "disabled",
-  enabled = "enabled",
-}
-export declare enum TransportProtocol {
-  tcp = "tcp",
-  udp = "udp",
-}
+export declare const SelfServicePortal: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+};
+export type SelfServicePortal =
+  (typeof SelfServicePortal)[keyof typeof SelfServicePortal];
+export declare const TransportProtocol: {
+  readonly tcp: "tcp";
+  readonly udp: "udp";
+};
+export type TransportProtocol =
+  (typeof TransportProtocol)[keyof typeof TransportProtocol];
 export interface CreateClientVpnEndpointRequest {
   ClientCidrBlock: string | undefined;
   ServerCertificateArn: string | undefined;
@@ -82,12 +88,14 @@ export interface CreateClientVpnEndpointRequest {
   SessionTimeoutHours?: number;
   ClientLoginBannerOptions?: ClientLoginBannerOptions;
 }
-export declare enum ClientVpnEndpointStatusCode {
-  available = "available",
-  deleted = "deleted",
-  deleting = "deleting",
-  pending_associate = "pending-associate",
-}
+export declare const ClientVpnEndpointStatusCode: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending_associate: "pending-associate";
+};
+export type ClientVpnEndpointStatusCode =
+  (typeof ClientVpnEndpointStatusCode)[keyof typeof ClientVpnEndpointStatusCode];
 export interface ClientVpnEndpointStatus {
   Code?: ClientVpnEndpointStatusCode | string;
   Message?: string;
@@ -105,12 +113,14 @@ export interface CreateClientVpnRouteRequest {
   ClientToken?: string;
   DryRun?: boolean;
 }
-export declare enum ClientVpnRouteStatusCode {
-  active = "active",
-  creating = "creating",
-  deleting = "deleting",
-  failed = "failed",
-}
+export declare const ClientVpnRouteStatusCode: {
+  readonly active: "active";
+  readonly creating: "creating";
+  readonly deleting: "deleting";
+  readonly failed: "failed";
+};
+export type ClientVpnRouteStatusCode =
+  (typeof ClientVpnRouteStatusCode)[keyof typeof ClientVpnRouteStatusCode];
 export interface ClientVpnRouteStatus {
   Code?: ClientVpnRouteStatusCode | string;
   Message?: string;
@@ -146,9 +156,10 @@ export interface CoipPool {
 export interface CreateCoipPoolResult {
   CoipPool?: CoipPool;
 }
-export declare enum GatewayType {
-  ipsec_1 = "ipsec.1",
-}
+export declare const GatewayType: {
+  readonly ipsec_1: "ipsec.1";
+};
+export type GatewayType = (typeof GatewayType)[keyof typeof GatewayType];
 export interface CreateCustomerGatewayRequest {
   BgpAsn?: number;
   PublicIp?: string;
@@ -177,19 +188,21 @@ export interface CreateDefaultSubnetRequest {
   DryRun?: boolean;
   Ipv6Native?: boolean;
 }
-export declare enum HostnameType {
-  ip_name = "ip-name",
-  resource_name = "resource-name",
-}
+export declare const HostnameType: {
+  readonly ip_name: "ip-name";
+  readonly resource_name: "resource-name";
+};
+export type HostnameType = (typeof HostnameType)[keyof typeof HostnameType];
 export interface PrivateDnsNameOptionsOnLaunch {
   HostnameType?: HostnameType | string;
   EnableResourceNameDnsARecord?: boolean;
   EnableResourceNameDnsAAAARecord?: boolean;
 }
-export declare enum SubnetState {
-  available = "available",
-  pending = "pending",
-}
+export declare const SubnetState: {
+  readonly available: "available";
+  readonly pending: "pending";
+};
+export type SubnetState = (typeof SubnetState)[keyof typeof SubnetState];
 export interface Subnet {
   AvailabilityZone?: string;
   AvailabilityZoneId?: string;
@@ -219,15 +232,17 @@ export interface CreateDefaultSubnetResult {
 export interface CreateDefaultVpcRequest {
   DryRun?: boolean;
 }
-export declare enum Tenancy {
-  dedicated = "dedicated",
-  default = "default",
-  host = "host",
-}
-export declare enum VpcState {
-  available = "available",
-  pending = "pending",
-}
+export declare const Tenancy: {
+  readonly dedicated: "dedicated";
+  readonly default: "default";
+  readonly host: "host";
+};
+export type Tenancy = (typeof Tenancy)[keyof typeof Tenancy];
+export declare const VpcState: {
+  readonly available: "available";
+  readonly pending: "pending";
+};
+export type VpcState = (typeof VpcState)[keyof typeof VpcState];
 export interface Vpc {
   CidrBlock?: string;
   DhcpOptionsId?: string;
@@ -287,47 +302,59 @@ export interface CreateEgressOnlyInternetGatewayResult {
   ClientToken?: string;
   EgressOnlyInternetGateway?: EgressOnlyInternetGateway;
 }
-export declare enum FleetExcessCapacityTerminationPolicy {
-  NO_TERMINATION = "no-termination",
-  TERMINATION = "termination",
-}
+export declare const FleetExcessCapacityTerminationPolicy: {
+  readonly NO_TERMINATION: "no-termination";
+  readonly TERMINATION: "termination";
+};
+export type FleetExcessCapacityTerminationPolicy =
+  (typeof FleetExcessCapacityTerminationPolicy)[keyof typeof FleetExcessCapacityTerminationPolicy];
 export interface FleetLaunchTemplateSpecificationRequest {
   LaunchTemplateId?: string;
   LaunchTemplateName?: string;
   Version?: string;
 }
-export declare enum BareMetal {
-  EXCLUDED = "excluded",
-  INCLUDED = "included",
-  REQUIRED = "required",
-}
+export declare const BareMetal: {
+  readonly EXCLUDED: "excluded";
+  readonly INCLUDED: "included";
+  readonly REQUIRED: "required";
+};
+export type BareMetal = (typeof BareMetal)[keyof typeof BareMetal];
 export interface BaselineEbsBandwidthMbpsRequest {
   Min?: number;
   Max?: number;
 }
-export declare enum BurstablePerformance {
-  EXCLUDED = "excluded",
-  INCLUDED = "included",
-  REQUIRED = "required",
-}
-export declare enum CpuManufacturer {
-  AMAZON_WEB_SERVICES = "amazon-web-services",
-  AMD = "amd",
-  INTEL = "intel",
-}
-export declare enum InstanceGeneration {
-  CURRENT = "current",
-  PREVIOUS = "previous",
-}
-export declare enum LocalStorage {
-  EXCLUDED = "excluded",
-  INCLUDED = "included",
-  REQUIRED = "required",
-}
-export declare enum LocalStorageType {
-  HDD = "hdd",
-  SSD = "ssd",
-}
+export declare const BurstablePerformance: {
+  readonly EXCLUDED: "excluded";
+  readonly INCLUDED: "included";
+  readonly REQUIRED: "required";
+};
+export type BurstablePerformance =
+  (typeof BurstablePerformance)[keyof typeof BurstablePerformance];
+export declare const CpuManufacturer: {
+  readonly AMAZON_WEB_SERVICES: "amazon-web-services";
+  readonly AMD: "amd";
+  readonly INTEL: "intel";
+};
+export type CpuManufacturer =
+  (typeof CpuManufacturer)[keyof typeof CpuManufacturer];
+export declare const InstanceGeneration: {
+  readonly CURRENT: "current";
+  readonly PREVIOUS: "previous";
+};
+export type InstanceGeneration =
+  (typeof InstanceGeneration)[keyof typeof InstanceGeneration];
+export declare const LocalStorage: {
+  readonly EXCLUDED: "excluded";
+  readonly INCLUDED: "included";
+  readonly REQUIRED: "required";
+};
+export type LocalStorage = (typeof LocalStorage)[keyof typeof LocalStorage];
+export declare const LocalStorageType: {
+  readonly HDD: "hdd";
+  readonly SSD: "ssd";
+};
+export type LocalStorageType =
+  (typeof LocalStorageType)[keyof typeof LocalStorageType];
 export interface MemoryGiBPerVCpuRequest {
   Min?: number;
   Max?: number;
@@ -403,13 +430,17 @@ export interface FleetLaunchTemplateConfigRequest {
   LaunchTemplateSpecification?: FleetLaunchTemplateSpecificationRequest;
   Overrides?: FleetLaunchTemplateOverridesRequest[];
 }
-export declare enum FleetOnDemandAllocationStrategy {
-  LOWEST_PRICE = "lowest-price",
-  PRIORITIZED = "prioritized",
-}
-export declare enum FleetCapacityReservationUsageStrategy {
-  USE_CAPACITY_RESERVATIONS_FIRST = "use-capacity-reservations-first",
-}
+export declare const FleetOnDemandAllocationStrategy: {
+  readonly LOWEST_PRICE: "lowest-price";
+  readonly PRIORITIZED: "prioritized";
+};
+export type FleetOnDemandAllocationStrategy =
+  (typeof FleetOnDemandAllocationStrategy)[keyof typeof FleetOnDemandAllocationStrategy];
+export declare const FleetCapacityReservationUsageStrategy: {
+  readonly USE_CAPACITY_RESERVATIONS_FIRST: "use-capacity-reservations-first";
+};
+export type FleetCapacityReservationUsageStrategy =
+  (typeof FleetCapacityReservationUsageStrategy)[keyof typeof FleetCapacityReservationUsageStrategy];
 export interface CapacityReservationOptionsRequest {
   UsageStrategy?: FleetCapacityReservationUsageStrategy | string;
 }
@@ -421,22 +452,28 @@ export interface OnDemandOptionsRequest {
   MinTargetCapacity?: number;
   MaxTotalPrice?: string;
 }
-export declare enum SpotAllocationStrategy {
-  CAPACITY_OPTIMIZED = "capacity-optimized",
-  CAPACITY_OPTIMIZED_PRIORITIZED = "capacity-optimized-prioritized",
-  DIVERSIFIED = "diversified",
-  LOWEST_PRICE = "lowest-price",
-  PRICE_CAPACITY_OPTIMIZED = "price-capacity-optimized",
-}
-export declare enum SpotInstanceInterruptionBehavior {
-  hibernate = "hibernate",
-  stop = "stop",
-  terminate = "terminate",
-}
-export declare enum FleetReplacementStrategy {
-  LAUNCH = "launch",
-  LAUNCH_BEFORE_TERMINATE = "launch-before-terminate",
-}
+export declare const SpotAllocationStrategy: {
+  readonly CAPACITY_OPTIMIZED: "capacity-optimized";
+  readonly CAPACITY_OPTIMIZED_PRIORITIZED: "capacity-optimized-prioritized";
+  readonly DIVERSIFIED: "diversified";
+  readonly LOWEST_PRICE: "lowest-price";
+  readonly PRICE_CAPACITY_OPTIMIZED: "price-capacity-optimized";
+};
+export type SpotAllocationStrategy =
+  (typeof SpotAllocationStrategy)[keyof typeof SpotAllocationStrategy];
+export declare const SpotInstanceInterruptionBehavior: {
+  readonly hibernate: "hibernate";
+  readonly stop: "stop";
+  readonly terminate: "terminate";
+};
+export type SpotInstanceInterruptionBehavior =
+  (typeof SpotInstanceInterruptionBehavior)[keyof typeof SpotInstanceInterruptionBehavior];
+export declare const FleetReplacementStrategy: {
+  readonly LAUNCH: "launch";
+  readonly LAUNCH_BEFORE_TERMINATE: "launch-before-terminate";
+};
+export type FleetReplacementStrategy =
+  (typeof FleetReplacementStrategy)[keyof typeof FleetReplacementStrategy];
 export interface FleetSpotCapacityRebalanceRequest {
   ReplacementStrategy?: FleetReplacementStrategy | string;
   TerminationDelay?: number;
@@ -454,15 +491,19 @@ export interface SpotOptionsRequest {
   MinTargetCapacity?: number;
   MaxTotalPrice?: string;
 }
-export declare enum DefaultTargetCapacityType {
-  ON_DEMAND = "on-demand",
-  SPOT = "spot",
-}
-export declare enum TargetCapacityUnitType {
-  MEMORY_MIB = "memory-mib",
-  UNITS = "units",
-  VCPU = "vcpu",
-}
+export declare const DefaultTargetCapacityType: {
+  readonly ON_DEMAND: "on-demand";
+  readonly SPOT: "spot";
+};
+export type DefaultTargetCapacityType =
+  (typeof DefaultTargetCapacityType)[keyof typeof DefaultTargetCapacityType];
+export declare const TargetCapacityUnitType: {
+  readonly MEMORY_MIB: "memory-mib";
+  readonly UNITS: "units";
+  readonly VCPU: "vcpu";
+};
+export type TargetCapacityUnitType =
+  (typeof TargetCapacityUnitType)[keyof typeof TargetCapacityUnitType];
 export interface TargetCapacitySpecificationRequest {
   TotalTargetCapacity: number | undefined;
   OnDemandTargetCapacity?: number;
@@ -470,11 +511,12 @@ export interface TargetCapacitySpecificationRequest {
   DefaultTargetCapacityType?: DefaultTargetCapacityType | string;
   TargetCapacityUnitType?: TargetCapacityUnitType | string;
 }
-export declare enum FleetType {
-  INSTANT = "instant",
-  MAINTAIN = "maintain",
-  REQUEST = "request",
-}
+export declare const FleetType: {
+  readonly INSTANT: "instant";
+  readonly MAINTAIN: "maintain";
+  readonly REQUEST: "request";
+};
+export type FleetType = (typeof FleetType)[keyof typeof FleetType];
 export interface CreateFleetRequest {
   DryRun?: boolean;
   ClientToken?: string;
@@ -569,19 +611,23 @@ export interface LaunchTemplateAndOverridesResponse {
   LaunchTemplateSpecification?: FleetLaunchTemplateSpecification;
   Overrides?: FleetLaunchTemplateOverrides;
 }
-export declare enum InstanceLifecycle {
-  ON_DEMAND = "on-demand",
-  SPOT = "spot",
-}
+export declare const InstanceLifecycle: {
+  readonly ON_DEMAND: "on-demand";
+  readonly SPOT: "spot";
+};
+export type InstanceLifecycle =
+  (typeof InstanceLifecycle)[keyof typeof InstanceLifecycle];
 export interface CreateFleetError {
   LaunchTemplateAndOverrides?: LaunchTemplateAndOverridesResponse;
   Lifecycle?: InstanceLifecycle | string;
   ErrorCode?: string;
   ErrorMessage?: string;
 }
-export declare enum PlatformValues {
-  Windows = "Windows",
-}
+export declare const PlatformValues: {
+  readonly Windows: "Windows";
+};
+export type PlatformValues =
+  (typeof PlatformValues)[keyof typeof PlatformValues];
 export interface CreateFleetInstance {
   LaunchTemplateAndOverrides?: LaunchTemplateAndOverridesResponse;
   Lifecycle?: InstanceLifecycle | string;
@@ -594,32 +640,39 @@ export interface CreateFleetResult {
   Errors?: CreateFleetError[];
   Instances?: CreateFleetInstance[];
 }
-export declare enum DestinationFileFormat {
-  parquet = "parquet",
-  plain_text = "plain-text",
-}
+export declare const DestinationFileFormat: {
+  readonly parquet: "parquet";
+  readonly plain_text: "plain-text";
+};
+export type DestinationFileFormat =
+  (typeof DestinationFileFormat)[keyof typeof DestinationFileFormat];
 export interface DestinationOptionsRequest {
   FileFormat?: DestinationFileFormat | string;
   HiveCompatiblePartitions?: boolean;
   PerHourPartition?: boolean;
 }
-export declare enum LogDestinationType {
-  cloud_watch_logs = "cloud-watch-logs",
-  kinesis_data_firehose = "kinesis-data-firehose",
-  s3 = "s3",
-}
-export declare enum FlowLogsResourceType {
-  NetworkInterface = "NetworkInterface",
-  Subnet = "Subnet",
-  TransitGateway = "TransitGateway",
-  TransitGatewayAttachment = "TransitGatewayAttachment",
-  VPC = "VPC",
-}
-export declare enum TrafficType {
-  ACCEPT = "ACCEPT",
-  ALL = "ALL",
-  REJECT = "REJECT",
-}
+export declare const LogDestinationType: {
+  readonly cloud_watch_logs: "cloud-watch-logs";
+  readonly kinesis_data_firehose: "kinesis-data-firehose";
+  readonly s3: "s3";
+};
+export type LogDestinationType =
+  (typeof LogDestinationType)[keyof typeof LogDestinationType];
+export declare const FlowLogsResourceType: {
+  readonly NetworkInterface: "NetworkInterface";
+  readonly Subnet: "Subnet";
+  readonly TransitGateway: "TransitGateway";
+  readonly TransitGatewayAttachment: "TransitGatewayAttachment";
+  readonly VPC: "VPC";
+};
+export type FlowLogsResourceType =
+  (typeof FlowLogsResourceType)[keyof typeof FlowLogsResourceType];
+export declare const TrafficType: {
+  readonly ACCEPT: "ACCEPT";
+  readonly ALL: "ALL";
+  readonly REJECT: "REJECT";
+};
+export type TrafficType = (typeof TrafficType)[keyof typeof TrafficType];
 export interface CreateFlowLogsRequest {
   DryRun?: boolean;
   ClientToken?: string;
@@ -658,15 +711,16 @@ export interface CreateFpgaImageResult {
   FpgaImageId?: string;
   FpgaImageGlobalId?: string;
 }
-export declare enum VolumeType {
-  gp2 = "gp2",
-  gp3 = "gp3",
-  io1 = "io1",
-  io2 = "io2",
-  sc1 = "sc1",
-  st1 = "st1",
-  standard = "standard",
-}
+export declare const VolumeType: {
+  readonly gp2: "gp2";
+  readonly gp3: "gp3";
+  readonly io1: "io1";
+  readonly io2: "io2";
+  readonly sc1: "sc1";
+  readonly st1: "st1";
+  readonly standard: "standard";
+};
+export type VolumeType = (typeof VolumeType)[keyof typeof VolumeType];
 export interface EbsBlockDevice {
   DeleteOnTermination?: boolean;
   Iops?: number;
@@ -712,25 +766,31 @@ export interface CreateInstanceEventWindowRequest {
 export interface CreateInstanceEventWindowResult {
   InstanceEventWindow?: InstanceEventWindow;
 }
-export declare enum ContainerFormat {
-  ova = "ova",
-}
-export declare enum DiskImageFormat {
-  RAW = "RAW",
-  VHD = "VHD",
-  VMDK = "VMDK",
-}
+export declare const ContainerFormat: {
+  readonly ova: "ova";
+};
+export type ContainerFormat =
+  (typeof ContainerFormat)[keyof typeof ContainerFormat];
+export declare const DiskImageFormat: {
+  readonly RAW: "RAW";
+  readonly VHD: "VHD";
+  readonly VMDK: "VMDK";
+};
+export type DiskImageFormat =
+  (typeof DiskImageFormat)[keyof typeof DiskImageFormat];
 export interface ExportToS3TaskSpecification {
   ContainerFormat?: ContainerFormat | string;
   DiskImageFormat?: DiskImageFormat | string;
   S3Bucket?: string;
   S3Prefix?: string;
 }
-export declare enum ExportEnvironment {
-  citrix = "citrix",
-  microsoft = "microsoft",
-  vmware = "vmware",
-}
+export declare const ExportEnvironment: {
+  readonly citrix: "citrix";
+  readonly microsoft: "microsoft";
+  readonly vmware: "vmware";
+};
+export type ExportEnvironment =
+  (typeof ExportEnvironment)[keyof typeof ExportEnvironment];
 export interface CreateInstanceExportTaskRequest {
   Description?: string;
   ExportToS3Task: ExportToS3TaskSpecification | undefined;
@@ -748,12 +808,14 @@ export interface InstanceExportDetails {
   InstanceId?: string;
   TargetEnvironment?: ExportEnvironment | string;
 }
-export declare enum ExportTaskState {
-  active = "active",
-  cancelled = "cancelled",
-  cancelling = "cancelling",
-  completed = "completed",
-}
+export declare const ExportTaskState: {
+  readonly active: "active";
+  readonly cancelled: "cancelled";
+  readonly cancelling: "cancelling";
+  readonly completed: "completed";
+};
+export type ExportTaskState =
+  (typeof ExportTaskState)[keyof typeof ExportTaskState];
 export interface ExportTask {
   Description?: string;
   ExportTaskId?: string;
@@ -789,20 +851,21 @@ export interface CreateIpamRequest {
 export interface IpamOperatingRegion {
   RegionName?: string;
 }
-export declare enum IpamState {
-  create_complete = "create-complete",
-  create_failed = "create-failed",
-  create_in_progress = "create-in-progress",
-  delete_complete = "delete-complete",
-  delete_failed = "delete-failed",
-  delete_in_progress = "delete-in-progress",
-  isolate_complete = "isolate-complete",
-  isolate_in_progress = "isolate-in-progress",
-  modify_complete = "modify-complete",
-  modify_failed = "modify-failed",
-  modify_in_progress = "modify-in-progress",
-  restore_in_progress = "restore-in-progress",
-}
+export declare const IpamState: {
+  readonly create_complete: "create-complete";
+  readonly create_failed: "create-failed";
+  readonly create_in_progress: "create-in-progress";
+  readonly delete_complete: "delete-complete";
+  readonly delete_failed: "delete-failed";
+  readonly delete_in_progress: "delete-in-progress";
+  readonly isolate_complete: "isolate-complete";
+  readonly isolate_in_progress: "isolate-in-progress";
+  readonly modify_complete: "modify-complete";
+  readonly modify_failed: "modify-failed";
+  readonly modify_in_progress: "modify-in-progress";
+  readonly restore_in_progress: "restore-in-progress";
+};
+export type IpamState = (typeof IpamState)[keyof typeof IpamState];
 export interface Ipam {
   OwnerId?: string;
   IpamId?: string;
@@ -826,13 +889,17 @@ export interface RequestIpamResourceTag {
   Key?: string;
   Value?: string;
 }
-export declare enum IpamPoolAwsService {
-  ec2 = "ec2",
-}
-export declare enum IpamPoolPublicIpSource {
-  amazon = "amazon",
-  byoip = "byoip",
-}
+export declare const IpamPoolAwsService: {
+  readonly ec2: "ec2";
+};
+export type IpamPoolAwsService =
+  (typeof IpamPoolAwsService)[keyof typeof IpamPoolAwsService];
+export declare const IpamPoolPublicIpSource: {
+  readonly amazon: "amazon";
+  readonly byoip: "byoip";
+};
+export type IpamPoolPublicIpSource =
+  (typeof IpamPoolPublicIpSource)[keyof typeof IpamPoolPublicIpSource];
 export interface CreateIpamPoolRequest {
   DryRun?: boolean;
   IpamScopeId: string | undefined;
@@ -855,24 +922,26 @@ export interface IpamResourceTag {
   Key?: string;
   Value?: string;
 }
-export declare enum IpamScopeType {
-  private = "private",
-  public = "public",
-}
-export declare enum IpamPoolState {
-  create_complete = "create-complete",
-  create_failed = "create-failed",
-  create_in_progress = "create-in-progress",
-  delete_complete = "delete-complete",
-  delete_failed = "delete-failed",
-  delete_in_progress = "delete-in-progress",
-  isolate_complete = "isolate-complete",
-  isolate_in_progress = "isolate-in-progress",
-  modify_complete = "modify-complete",
-  modify_failed = "modify-failed",
-  modify_in_progress = "modify-in-progress",
-  restore_in_progress = "restore-in-progress",
-}
+export declare const IpamScopeType: {
+  readonly private: "private";
+  readonly public: "public";
+};
+export type IpamScopeType = (typeof IpamScopeType)[keyof typeof IpamScopeType];
+export declare const IpamPoolState: {
+  readonly create_complete: "create-complete";
+  readonly create_failed: "create-failed";
+  readonly create_in_progress: "create-in-progress";
+  readonly delete_complete: "delete-complete";
+  readonly delete_failed: "delete-failed";
+  readonly delete_in_progress: "delete-in-progress";
+  readonly isolate_complete: "isolate-complete";
+  readonly isolate_in_progress: "isolate-in-progress";
+  readonly modify_complete: "modify-complete";
+  readonly modify_failed: "modify-failed";
+  readonly modify_in_progress: "modify-in-progress";
+  readonly restore_in_progress: "restore-in-progress";
+};
+export type IpamPoolState = (typeof IpamPoolState)[keyof typeof IpamPoolState];
 export interface IpamPool {
   OwnerId?: string;
   IpamPoolId?: string;
@@ -908,20 +977,22 @@ export interface CreateIpamResourceDiscoveryRequest {
   TagSpecifications?: TagSpecification[];
   ClientToken?: string;
 }
-export declare enum IpamResourceDiscoveryState {
-  CREATE_COMPLETE = "create-complete",
-  CREATE_FAILED = "create-failed",
-  CREATE_IN_PROGRESS = "create-in-progress",
-  DELETE_COMPLETE = "delete-complete",
-  DELETE_FAILED = "delete-failed",
-  DELETE_IN_PROGRESS = "delete-in-progress",
-  ISOLATE_COMPLETE = "isolate-complete",
-  ISOLATE_IN_PROGRESS = "isolate-in-progress",
-  MODIFY_COMPLETE = "modify-complete",
-  MODIFY_FAILED = "modify-failed",
-  MODIFY_IN_PROGRESS = "modify-in-progress",
-  RESTORE_IN_PROGRESS = "restore-in-progress",
-}
+export declare const IpamResourceDiscoveryState: {
+  readonly CREATE_COMPLETE: "create-complete";
+  readonly CREATE_FAILED: "create-failed";
+  readonly CREATE_IN_PROGRESS: "create-in-progress";
+  readonly DELETE_COMPLETE: "delete-complete";
+  readonly DELETE_FAILED: "delete-failed";
+  readonly DELETE_IN_PROGRESS: "delete-in-progress";
+  readonly ISOLATE_COMPLETE: "isolate-complete";
+  readonly ISOLATE_IN_PROGRESS: "isolate-in-progress";
+  readonly MODIFY_COMPLETE: "modify-complete";
+  readonly MODIFY_FAILED: "modify-failed";
+  readonly MODIFY_IN_PROGRESS: "modify-in-progress";
+  readonly RESTORE_IN_PROGRESS: "restore-in-progress";
+};
+export type IpamResourceDiscoveryState =
+  (typeof IpamResourceDiscoveryState)[keyof typeof IpamResourceDiscoveryState];
 export interface IpamResourceDiscovery {
   OwnerId?: string;
   IpamResourceDiscoveryId?: string;
@@ -943,20 +1014,22 @@ export interface CreateIpamScopeRequest {
   TagSpecifications?: TagSpecification[];
   ClientToken?: string;
 }
-export declare enum IpamScopeState {
-  create_complete = "create-complete",
-  create_failed = "create-failed",
-  create_in_progress = "create-in-progress",
-  delete_complete = "delete-complete",
-  delete_failed = "delete-failed",
-  delete_in_progress = "delete-in-progress",
-  isolate_complete = "isolate-complete",
-  isolate_in_progress = "isolate-in-progress",
-  modify_complete = "modify-complete",
-  modify_failed = "modify-failed",
-  modify_in_progress = "modify-in-progress",
-  restore_in_progress = "restore-in-progress",
-}
+export declare const IpamScopeState: {
+  readonly create_complete: "create-complete";
+  readonly create_failed: "create-failed";
+  readonly create_in_progress: "create-in-progress";
+  readonly delete_complete: "delete-complete";
+  readonly delete_failed: "delete-failed";
+  readonly delete_in_progress: "delete-in-progress";
+  readonly isolate_complete: "isolate-complete";
+  readonly isolate_in_progress: "isolate-in-progress";
+  readonly modify_complete: "modify-complete";
+  readonly modify_failed: "modify-failed";
+  readonly modify_in_progress: "modify-in-progress";
+  readonly restore_in_progress: "restore-in-progress";
+};
+export type IpamScopeState =
+  (typeof IpamScopeState)[keyof typeof IpamScopeState];
 export interface IpamScope {
   OwnerId?: string;
   IpamScopeId?: string;
@@ -973,14 +1046,16 @@ export interface IpamScope {
 export interface CreateIpamScopeResult {
   IpamScope?: IpamScope;
 }
-export declare enum KeyFormat {
-  pem = "pem",
-  ppk = "ppk",
-}
-export declare enum KeyType {
-  ed25519 = "ed25519",
-  rsa = "rsa",
-}
+export declare const KeyFormat: {
+  readonly pem: "pem";
+  readonly ppk: "ppk";
+};
+export type KeyFormat = (typeof KeyFormat)[keyof typeof KeyFormat];
+export declare const KeyType: {
+  readonly ed25519: "ed25519";
+  readonly rsa: "rsa";
+};
+export type KeyType = (typeof KeyType)[keyof typeof KeyType];
 export interface CreateKeyPairRequest {
   KeyName: string | undefined;
   DryRun?: boolean;
@@ -1011,10 +1086,12 @@ export interface LaunchTemplateBlockDeviceMappingRequest {
   Ebs?: LaunchTemplateEbsBlockDeviceRequest;
   NoDevice?: string;
 }
-export declare enum CapacityReservationPreference {
-  none = "none",
-  open = "open",
-}
+export declare const CapacityReservationPreference: {
+  readonly none: "none";
+  readonly open: "open";
+};
+export type CapacityReservationPreference =
+  (typeof CapacityReservationPreference)[keyof typeof CapacityReservationPreference];
 export interface CapacityReservationTarget {
   CapacityReservationId?: string;
   CapacityReservationResourceGroupArn?: string;
@@ -1047,22 +1124,29 @@ export interface LaunchTemplateIamInstanceProfileSpecificationRequest {
   Arn?: string;
   Name?: string;
 }
-export declare enum ShutdownBehavior {
-  stop = "stop",
-  terminate = "terminate",
-}
-export declare enum MarketType {
-  spot = "spot",
-}
-export declare enum InstanceInterruptionBehavior {
-  hibernate = "hibernate",
-  stop = "stop",
-  terminate = "terminate",
-}
-export declare enum SpotInstanceType {
-  one_time = "one-time",
-  persistent = "persistent",
-}
+export declare const ShutdownBehavior: {
+  readonly stop: "stop";
+  readonly terminate: "terminate";
+};
+export type ShutdownBehavior =
+  (typeof ShutdownBehavior)[keyof typeof ShutdownBehavior];
+export declare const MarketType: {
+  readonly spot: "spot";
+};
+export type MarketType = (typeof MarketType)[keyof typeof MarketType];
+export declare const InstanceInterruptionBehavior: {
+  readonly hibernate: "hibernate";
+  readonly stop: "stop";
+  readonly terminate: "terminate";
+};
+export type InstanceInterruptionBehavior =
+  (typeof InstanceInterruptionBehavior)[keyof typeof InstanceInterruptionBehavior];
+export declare const SpotInstanceType: {
+  readonly one_time: "one-time";
+  readonly persistent: "persistent";
+};
+export type SpotInstanceType =
+  (typeof SpotInstanceType)[keyof typeof SpotInstanceType];
 export interface LaunchTemplateSpotMarketOptionsRequest {
   MaxPrice?: string;
   SpotInstanceType?: SpotInstanceType | string;
@@ -1077,29 +1161,39 @@ export interface LaunchTemplateInstanceMarketOptionsRequest {
 export interface LaunchTemplateLicenseConfigurationRequest {
   LicenseConfigurationArn?: string;
 }
-export declare enum LaunchTemplateAutoRecoveryState {
-  default = "default",
-  disabled = "disabled",
-}
+export declare const LaunchTemplateAutoRecoveryState: {
+  readonly default: "default";
+  readonly disabled: "disabled";
+};
+export type LaunchTemplateAutoRecoveryState =
+  (typeof LaunchTemplateAutoRecoveryState)[keyof typeof LaunchTemplateAutoRecoveryState];
 export interface LaunchTemplateInstanceMaintenanceOptionsRequest {
   AutoRecovery?: LaunchTemplateAutoRecoveryState | string;
 }
-export declare enum LaunchTemplateInstanceMetadataEndpointState {
-  disabled = "disabled",
-  enabled = "enabled",
-}
-export declare enum LaunchTemplateInstanceMetadataProtocolIpv6 {
-  disabled = "disabled",
-  enabled = "enabled",
-}
-export declare enum LaunchTemplateHttpTokensState {
-  optional = "optional",
-  required = "required",
-}
-export declare enum LaunchTemplateInstanceMetadataTagsState {
-  disabled = "disabled",
-  enabled = "enabled",
-}
+export declare const LaunchTemplateInstanceMetadataEndpointState: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+};
+export type LaunchTemplateInstanceMetadataEndpointState =
+  (typeof LaunchTemplateInstanceMetadataEndpointState)[keyof typeof LaunchTemplateInstanceMetadataEndpointState];
+export declare const LaunchTemplateInstanceMetadataProtocolIpv6: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+};
+export type LaunchTemplateInstanceMetadataProtocolIpv6 =
+  (typeof LaunchTemplateInstanceMetadataProtocolIpv6)[keyof typeof LaunchTemplateInstanceMetadataProtocolIpv6];
+export declare const LaunchTemplateHttpTokensState: {
+  readonly optional: "optional";
+  readonly required: "required";
+};
+export type LaunchTemplateHttpTokensState =
+  (typeof LaunchTemplateHttpTokensState)[keyof typeof LaunchTemplateHttpTokensState];
+export declare const LaunchTemplateInstanceMetadataTagsState: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+};
+export type LaunchTemplateInstanceMetadataTagsState =
+  (typeof LaunchTemplateInstanceMetadataTagsState)[keyof typeof LaunchTemplateInstanceMetadataTagsState];
 export interface LaunchTemplateInstanceMetadataOptionsRequest {
   HttpTokens?: LaunchTemplateHttpTokensState | string;
   HttpPutResponseHopLimit?: number;
@@ -1300,10 +1394,12 @@ export interface LaunchTemplateLicenseConfiguration {
 export interface LaunchTemplateInstanceMaintenanceOptions {
   AutoRecovery?: LaunchTemplateAutoRecoveryState | string;
 }
-export declare enum LaunchTemplateInstanceMetadataOptionsState {
-  applied = "applied",
-  pending = "pending",
-}
+export declare const LaunchTemplateInstanceMetadataOptionsState: {
+  readonly applied: "applied";
+  readonly pending: "pending";
+};
+export type LaunchTemplateInstanceMetadataOptionsState =
+  (typeof LaunchTemplateInstanceMetadataOptionsState)[keyof typeof LaunchTemplateInstanceMetadataOptionsState];
 export interface LaunchTemplateInstanceMetadataOptions {
   State?: LaunchTemplateInstanceMetadataOptionsState | string;
   HttpTokens?: LaunchTemplateHttpTokensState | string;
@@ -1420,17 +1516,21 @@ export interface CreateLocalGatewayRouteRequest {
   NetworkInterfaceId?: string;
   DestinationPrefixListId?: string;
 }
-export declare enum LocalGatewayRouteState {
-  active = "active",
-  blackhole = "blackhole",
-  deleted = "deleted",
-  deleting = "deleting",
-  pending = "pending",
-}
-export declare enum LocalGatewayRouteType {
-  propagated = "propagated",
-  static = "static",
-}
+export declare const LocalGatewayRouteState: {
+  readonly active: "active";
+  readonly blackhole: "blackhole";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending: "pending";
+};
+export type LocalGatewayRouteState =
+  (typeof LocalGatewayRouteState)[keyof typeof LocalGatewayRouteState];
+export declare const LocalGatewayRouteType: {
+  readonly propagated: "propagated";
+  readonly static: "static";
+};
+export type LocalGatewayRouteType =
+  (typeof LocalGatewayRouteType)[keyof typeof LocalGatewayRouteType];
 export interface LocalGatewayRoute {
   DestinationCidrBlock?: string;
   LocalGatewayVirtualInterfaceGroupId?: string;
@@ -1447,10 +1547,12 @@ export interface LocalGatewayRoute {
 export interface CreateLocalGatewayRouteResult {
   Route?: LocalGatewayRoute;
 }
-export declare enum LocalGatewayRouteTableMode {
-  coip = "coip",
-  direct_vpc_routing = "direct-vpc-routing",
-}
+export declare const LocalGatewayRouteTableMode: {
+  readonly coip: "coip";
+  readonly direct_vpc_routing: "direct-vpc-routing";
+};
+export type LocalGatewayRouteTableMode =
+  (typeof LocalGatewayRouteTableMode)[keyof typeof LocalGatewayRouteTableMode];
 export interface CreateLocalGatewayRouteTableRequest {
   LocalGatewayId: string | undefined;
   Mode?: LocalGatewayRouteTableMode | string;
@@ -1522,20 +1624,22 @@ export interface CreateManagedPrefixListRequest {
   AddressFamily: string | undefined;
   ClientToken?: string;
 }
-export declare enum PrefixListState {
-  create_complete = "create-complete",
-  create_failed = "create-failed",
-  create_in_progress = "create-in-progress",
-  delete_complete = "delete-complete",
-  delete_failed = "delete-failed",
-  delete_in_progress = "delete-in-progress",
-  modify_complete = "modify-complete",
-  modify_failed = "modify-failed",
-  modify_in_progress = "modify-in-progress",
-  restore_complete = "restore-complete",
-  restore_failed = "restore-failed",
-  restore_in_progress = "restore-in-progress",
-}
+export declare const PrefixListState: {
+  readonly create_complete: "create-complete";
+  readonly create_failed: "create-failed";
+  readonly create_in_progress: "create-in-progress";
+  readonly delete_complete: "delete-complete";
+  readonly delete_failed: "delete-failed";
+  readonly delete_in_progress: "delete-in-progress";
+  readonly modify_complete: "modify-complete";
+  readonly modify_failed: "modify-failed";
+  readonly modify_in_progress: "modify-in-progress";
+  readonly restore_complete: "restore-complete";
+  readonly restore_failed: "restore-failed";
+  readonly restore_in_progress: "restore-in-progress";
+};
+export type PrefixListState =
+  (typeof PrefixListState)[keyof typeof PrefixListState];
 export interface ManagedPrefixList {
   PrefixListId?: string;
   AddressFamily?: string;
@@ -1551,10 +1655,12 @@ export interface ManagedPrefixList {
 export interface CreateManagedPrefixListResult {
   PrefixList?: ManagedPrefixList;
 }
-export declare enum ConnectivityType {
-  PRIVATE = "private",
-  PUBLIC = "public",
-}
+export declare const ConnectivityType: {
+  readonly PRIVATE: "private";
+  readonly PUBLIC: "public";
+};
+export type ConnectivityType =
+  (typeof ConnectivityType)[keyof typeof ConnectivityType];
 export interface CreateNatGatewayRequest {
   AllocationId?: string;
   ClientToken?: string;
@@ -1574,13 +1680,15 @@ export interface ProvisionedBandwidth {
   Requested?: string;
   Status?: string;
 }
-export declare enum NatGatewayState {
-  AVAILABLE = "available",
-  DELETED = "deleted",
-  DELETING = "deleting",
-  FAILED = "failed",
-  PENDING = "pending",
-}
+export declare const NatGatewayState: {
+  readonly AVAILABLE: "available";
+  readonly DELETED: "deleted";
+  readonly DELETING: "deleting";
+  readonly FAILED: "failed";
+  readonly PENDING: "pending";
+};
+export type NatGatewayState =
+  (typeof NatGatewayState)[keyof typeof NatGatewayState];
 export interface NatGateway {
   CreateTime?: Date;
   DeleteTime?: Date;
@@ -1613,10 +1721,11 @@ export interface IcmpTypeCode {
   Code?: number;
   Type?: number;
 }
-export declare enum RuleAction {
-  allow = "allow",
-  deny = "deny",
-}
+export declare const RuleAction: {
+  readonly allow: "allow";
+  readonly deny: "deny";
+};
+export type RuleAction = (typeof RuleAction)[keyof typeof RuleAction];
 export interface NetworkAclEntry {
   CidrBlock?: string;
   Egress?: boolean;
@@ -1726,11 +1835,13 @@ export interface NetworkInsightsPath {
 export interface CreateNetworkInsightsPathResult {
   NetworkInsightsPath?: NetworkInsightsPath;
 }
-export declare enum NetworkInterfaceCreationType {
-  branch = "branch",
-  efa = "efa",
-  trunk = "trunk",
-}
+export declare const NetworkInterfaceCreationType: {
+  readonly branch: "branch";
+  readonly efa: "efa";
+  readonly trunk: "trunk";
+};
+export type NetworkInterfaceCreationType =
+  (typeof NetworkInterfaceCreationType)[keyof typeof NetworkInterfaceCreationType];
 export interface CreateNetworkInterfaceRequest {
   Description?: string;
   DryRun?: boolean;
@@ -1780,25 +1891,27 @@ export interface GroupIdentifier {
   GroupName?: string;
   GroupId?: string;
 }
-export declare enum NetworkInterfaceType {
-  api_gateway_managed = "api_gateway_managed",
-  aws_codestar_connections_managed = "aws_codestar_connections_managed",
-  branch = "branch",
-  efa = "efa",
-  gateway_load_balancer = "gateway_load_balancer",
-  gateway_load_balancer_endpoint = "gateway_load_balancer_endpoint",
-  global_accelerator_managed = "global_accelerator_managed",
-  interface = "interface",
-  iot_rules_managed = "iot_rules_managed",
-  lambda = "lambda",
-  load_balancer = "load_balancer",
-  natGateway = "natGateway",
-  network_load_balancer = "network_load_balancer",
-  quicksight = "quicksight",
-  transit_gateway = "transit_gateway",
-  trunk = "trunk",
-  vpc_endpoint = "vpc_endpoint",
-}
+export declare const NetworkInterfaceType: {
+  readonly api_gateway_managed: "api_gateway_managed";
+  readonly aws_codestar_connections_managed: "aws_codestar_connections_managed";
+  readonly branch: "branch";
+  readonly efa: "efa";
+  readonly gateway_load_balancer: "gateway_load_balancer";
+  readonly gateway_load_balancer_endpoint: "gateway_load_balancer_endpoint";
+  readonly global_accelerator_managed: "global_accelerator_managed";
+  readonly interface: "interface";
+  readonly iot_rules_managed: "iot_rules_managed";
+  readonly lambda: "lambda";
+  readonly load_balancer: "load_balancer";
+  readonly natGateway: "natGateway";
+  readonly network_load_balancer: "network_load_balancer";
+  readonly quicksight: "quicksight";
+  readonly transit_gateway: "transit_gateway";
+  readonly trunk: "trunk";
+  readonly vpc_endpoint: "vpc_endpoint";
+};
+export type NetworkInterfaceType =
+  (typeof NetworkInterfaceType)[keyof typeof NetworkInterfaceType];
 export interface NetworkInterfaceIpv6Address {
   Ipv6Address?: string;
 }
@@ -1811,13 +1924,15 @@ export interface NetworkInterfacePrivateIpAddress {
   PrivateDnsName?: string;
   PrivateIpAddress?: string;
 }
-export declare enum NetworkInterfaceStatus {
-  associated = "associated",
-  attaching = "attaching",
-  available = "available",
-  detaching = "detaching",
-  in_use = "in-use",
-}
+export declare const NetworkInterfaceStatus: {
+  readonly associated: "associated";
+  readonly attaching: "attaching";
+  readonly available: "available";
+  readonly detaching: "detaching";
+  readonly in_use: "in-use";
+};
+export type NetworkInterfaceStatus =
+  (typeof NetworkInterfaceStatus)[keyof typeof NetworkInterfaceStatus];
 export interface NetworkInterface {
   Association?: NetworkInterfaceAssociation;
   Attachment?: NetworkInterfaceAttachment;
@@ -1850,10 +1965,12 @@ export interface CreateNetworkInterfaceResult {
   NetworkInterface?: NetworkInterface;
   ClientToken?: string;
 }
-export declare enum InterfacePermissionType {
-  EIP_ASSOCIATE = "EIP-ASSOCIATE",
-  INSTANCE_ATTACH = "INSTANCE-ATTACH",
-}
+export declare const InterfacePermissionType: {
+  readonly EIP_ASSOCIATE: "EIP-ASSOCIATE";
+  readonly INSTANCE_ATTACH: "INSTANCE-ATTACH";
+};
+export type InterfacePermissionType =
+  (typeof InterfacePermissionType)[keyof typeof InterfacePermissionType];
 export interface CreateNetworkInterfacePermissionRequest {
   NetworkInterfaceId: string | undefined;
   AwsAccountId?: string;
@@ -1861,12 +1978,14 @@ export interface CreateNetworkInterfacePermissionRequest {
   Permission: InterfacePermissionType | string | undefined;
   DryRun?: boolean;
 }
-export declare enum NetworkInterfacePermissionStateCode {
-  granted = "granted",
-  pending = "pending",
-  revoked = "revoked",
-  revoking = "revoking",
-}
+export declare const NetworkInterfacePermissionStateCode: {
+  readonly granted: "granted";
+  readonly pending: "pending";
+  readonly revoked: "revoked";
+  readonly revoking: "revoking";
+};
+export type NetworkInterfacePermissionStateCode =
+  (typeof NetworkInterfacePermissionStateCode)[keyof typeof NetworkInterfacePermissionStateCode];
 export interface NetworkInterfacePermissionState {
   State?: NetworkInterfacePermissionStateCode | string;
   StatusMessage?: string;
@@ -1882,15 +2001,18 @@ export interface NetworkInterfacePermission {
 export interface CreateNetworkInterfacePermissionResult {
   InterfacePermission?: NetworkInterfacePermission;
 }
-export declare enum SpreadLevel {
-  host = "host",
-  rack = "rack",
-}
-export declare enum PlacementStrategy {
-  cluster = "cluster",
-  partition = "partition",
-  spread = "spread",
-}
+export declare const SpreadLevel: {
+  readonly host: "host";
+  readonly rack: "rack";
+};
+export type SpreadLevel = (typeof SpreadLevel)[keyof typeof SpreadLevel];
+export declare const PlacementStrategy: {
+  readonly cluster: "cluster";
+  readonly partition: "partition";
+  readonly spread: "spread";
+};
+export type PlacementStrategy =
+  (typeof PlacementStrategy)[keyof typeof PlacementStrategy];
 export interface CreatePlacementGroupRequest {
   DryRun?: boolean;
   GroupName?: string;
@@ -1899,12 +2021,14 @@ export interface CreatePlacementGroupRequest {
   TagSpecifications?: TagSpecification[];
   SpreadLevel?: SpreadLevel | string;
 }
-export declare enum PlacementGroupState {
-  available = "available",
-  deleted = "deleted",
-  deleting = "deleting",
-  pending = "pending",
-}
+export declare const PlacementGroupState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending: "pending";
+};
+export type PlacementGroupState =
+  (typeof PlacementGroupState)[keyof typeof PlacementGroupState];
 export interface PlacementGroup {
   GroupName?: string;
   State?: PlacementGroupState | string;
@@ -1934,14 +2058,16 @@ export interface CreateReplaceRootVolumeTaskRequest {
   ImageId?: string;
   DeleteReplacedRootVolume?: boolean;
 }
-export declare enum ReplaceRootVolumeTaskState {
-  failed = "failed",
-  failed_detached = "failed-detached",
-  failing = "failing",
-  in_progress = "in-progress",
-  pending = "pending",
-  succeeded = "succeeded",
-}
+export declare const ReplaceRootVolumeTaskState: {
+  readonly failed: "failed";
+  readonly failed_detached: "failed-detached";
+  readonly failing: "failing";
+  readonly in_progress: "in-progress";
+  readonly pending: "pending";
+  readonly succeeded: "succeeded";
+};
+export type ReplaceRootVolumeTaskState =
+  (typeof ReplaceRootVolumeTaskState)[keyof typeof ReplaceRootVolumeTaskState];
 export interface ReplaceRootVolumeTask {
   ReplaceRootVolumeTaskId?: string;
   InstanceId?: string;