@aws-sdk/client-ec2 3.934.0 → 3.935.0

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

@@ -0,0 +1,4361 @@
+export declare const AcceleratorManufacturer: {
+  readonly AMAZON_WEB_SERVICES: "amazon-web-services";
+  readonly AMD: "amd";
+  readonly HABANA: "habana";
+  readonly NVIDIA: "nvidia";
+  readonly XILINX: "xilinx";
+};
+export type AcceleratorManufacturer =
+  (typeof AcceleratorManufacturer)[keyof typeof AcceleratorManufacturer];
+export declare const AcceleratorName: {
+  readonly A100: "a100";
+  readonly A10G: "a10g";
+  readonly GAUDI_HL_205: "gaudi-hl-205";
+  readonly H100: "h100";
+  readonly INFERENTIA: "inferentia";
+  readonly INFERENTIA2: "inferentia2";
+  readonly K520: "k520";
+  readonly K80: "k80";
+  readonly L4: "l4";
+  readonly L40S: "l40s";
+  readonly M60: "m60";
+  readonly RADEON_PRO_V520: "radeon-pro-v520";
+  readonly T4: "t4";
+  readonly T4G: "t4g";
+  readonly TRAINIUM: "trainium";
+  readonly TRAINIUM2: "trainium2";
+  readonly U30: "u30";
+  readonly V100: "v100";
+  readonly VU9P: "vu9p";
+};
+export type AcceleratorName =
+  (typeof AcceleratorName)[keyof typeof AcceleratorName];
+export declare const AcceleratorType: {
+  readonly FPGA: "fpga";
+  readonly GPU: "gpu";
+  readonly INFERENCE: "inference";
+  readonly MEDIA: "media";
+};
+export type AcceleratorType =
+  (typeof AcceleratorType)[keyof typeof AcceleratorType];
+export declare const ResourceType: {
+  readonly capacity_block: "capacity-block";
+  readonly capacity_manager_data_export: "capacity-manager-data-export";
+  readonly capacity_reservation: "capacity-reservation";
+  readonly capacity_reservation_fleet: "capacity-reservation-fleet";
+  readonly carrier_gateway: "carrier-gateway";
+  readonly client_vpn_endpoint: "client-vpn-endpoint";
+  readonly coip_pool: "coip-pool";
+  readonly customer_gateway: "customer-gateway";
+  readonly declarative_policies_report: "declarative-policies-report";
+  readonly dedicated_host: "dedicated-host";
+  readonly dhcp_options: "dhcp-options";
+  readonly egress_only_internet_gateway: "egress-only-internet-gateway";
+  readonly elastic_gpu: "elastic-gpu";
+  readonly elastic_ip: "elastic-ip";
+  readonly export_image_task: "export-image-task";
+  readonly export_instance_task: "export-instance-task";
+  readonly fleet: "fleet";
+  readonly fpga_image: "fpga-image";
+  readonly host_reservation: "host-reservation";
+  readonly image: "image";
+  readonly image_usage_report: "image-usage-report";
+  readonly import_image_task: "import-image-task";
+  readonly import_snapshot_task: "import-snapshot-task";
+  readonly instance: "instance";
+  readonly instance_connect_endpoint: "instance-connect-endpoint";
+  readonly instance_event_window: "instance-event-window";
+  readonly internet_gateway: "internet-gateway";
+  readonly ipam: "ipam";
+  readonly ipam_external_resource_verification_token: "ipam-external-resource-verification-token";
+  readonly ipam_policy: "ipam-policy";
+  readonly ipam_pool: "ipam-pool";
+  readonly ipam_prefix_list_resolver: "ipam-prefix-list-resolver";
+  readonly ipam_prefix_list_resolver_target: "ipam-prefix-list-resolver-target";
+  readonly ipam_resource_discovery: "ipam-resource-discovery";
+  readonly ipam_resource_discovery_association: "ipam-resource-discovery-association";
+  readonly ipam_scope: "ipam-scope";
+  readonly ipv4pool_ec2: "ipv4pool-ec2";
+  readonly ipv6pool_ec2: "ipv6pool-ec2";
+  readonly key_pair: "key-pair";
+  readonly launch_template: "launch-template";
+  readonly local_gateway: "local-gateway";
+  readonly local_gateway_route_table: "local-gateway-route-table";
+  readonly local_gateway_route_table_virtual_interface_group_association: "local-gateway-route-table-virtual-interface-group-association";
+  readonly local_gateway_route_table_vpc_association: "local-gateway-route-table-vpc-association";
+  readonly local_gateway_virtual_interface: "local-gateway-virtual-interface";
+  readonly local_gateway_virtual_interface_group: "local-gateway-virtual-interface-group";
+  readonly mac_modification_task: "mac-modification-task";
+  readonly natgateway: "natgateway";
+  readonly network_acl: "network-acl";
+  readonly network_insights_access_scope: "network-insights-access-scope";
+  readonly network_insights_access_scope_analysis: "network-insights-access-scope-analysis";
+  readonly network_insights_analysis: "network-insights-analysis";
+  readonly network_insights_path: "network-insights-path";
+  readonly network_interface: "network-interface";
+  readonly outpost_lag: "outpost-lag";
+  readonly placement_group: "placement-group";
+  readonly prefix_list: "prefix-list";
+  readonly replace_root_volume_task: "replace-root-volume-task";
+  readonly reserved_instances: "reserved-instances";
+  readonly route_server: "route-server";
+  readonly route_server_endpoint: "route-server-endpoint";
+  readonly route_server_peer: "route-server-peer";
+  readonly route_table: "route-table";
+  readonly security_group: "security-group";
+  readonly security_group_rule: "security-group-rule";
+  readonly service_link_virtual_interface: "service-link-virtual-interface";
+  readonly snapshot: "snapshot";
+  readonly spot_fleet_request: "spot-fleet-request";
+  readonly spot_instances_request: "spot-instances-request";
+  readonly subnet: "subnet";
+  readonly subnet_cidr_reservation: "subnet-cidr-reservation";
+  readonly traffic_mirror_filter: "traffic-mirror-filter";
+  readonly traffic_mirror_filter_rule: "traffic-mirror-filter-rule";
+  readonly traffic_mirror_session: "traffic-mirror-session";
+  readonly traffic_mirror_target: "traffic-mirror-target";
+  readonly transit_gateway: "transit-gateway";
+  readonly transit_gateway_attachment: "transit-gateway-attachment";
+  readonly transit_gateway_connect_peer: "transit-gateway-connect-peer";
+  readonly transit_gateway_multicast_domain: "transit-gateway-multicast-domain";
+  readonly transit_gateway_policy_table: "transit-gateway-policy-table";
+  readonly transit_gateway_route_table: "transit-gateway-route-table";
+  readonly transit_gateway_route_table_announcement: "transit-gateway-route-table-announcement";
+  readonly verified_access_endpoint: "verified-access-endpoint";
+  readonly verified_access_endpoint_target: "verified-access-endpoint-target";
+  readonly verified_access_group: "verified-access-group";
+  readonly verified_access_instance: "verified-access-instance";
+  readonly verified_access_policy: "verified-access-policy";
+  readonly verified_access_trust_provider: "verified-access-trust-provider";
+  readonly volume: "volume";
+  readonly vpc: "vpc";
+  readonly vpc_block_public_access_exclusion: "vpc-block-public-access-exclusion";
+  readonly vpc_endpoint: "vpc-endpoint";
+  readonly vpc_endpoint_connection: "vpc-endpoint-connection";
+  readonly vpc_endpoint_connection_device_type: "vpc-endpoint-connection-device-type";
+  readonly vpc_endpoint_service: "vpc-endpoint-service";
+  readonly vpc_endpoint_service_permission: "vpc-endpoint-service-permission";
+  readonly vpc_flow_log: "vpc-flow-log";
+  readonly vpc_peering_connection: "vpc-peering-connection";
+  readonly vpn_concentrator: "vpn-concentrator";
+  readonly vpn_connection: "vpn-connection";
+  readonly vpn_connection_device_type: "vpn-connection-device-type";
+  readonly vpn_gateway: "vpn-gateway";
+};
+export type ResourceType = (typeof ResourceType)[keyof typeof ResourceType];
+export declare const AddressTransferStatus: {
+  readonly accepted: "accepted";
+  readonly disabled: "disabled";
+  readonly pending: "pending";
+};
+export type AddressTransferStatus =
+  (typeof AddressTransferStatus)[keyof typeof AddressTransferStatus];
+export declare const TransitGatewayAttachmentResourceType: {
+  readonly connect: "connect";
+  readonly direct_connect_gateway: "direct-connect-gateway";
+  readonly network_function: "network-function";
+  readonly peering: "peering";
+  readonly tgw_peering: "tgw-peering";
+  readonly vpc: "vpc";
+  readonly vpn: "vpn";
+  readonly vpn_concentrator: "vpn-concentrator";
+};
+export type TransitGatewayAttachmentResourceType =
+  (typeof TransitGatewayAttachmentResourceType)[keyof typeof TransitGatewayAttachmentResourceType];
+export declare const TransitGatewayMulitcastDomainAssociationState: {
+  readonly associated: "associated";
+  readonly associating: "associating";
+  readonly disassociated: "disassociated";
+  readonly disassociating: "disassociating";
+  readonly failed: "failed";
+  readonly pendingAcceptance: "pendingAcceptance";
+  readonly rejected: "rejected";
+};
+export type TransitGatewayMulitcastDomainAssociationState =
+  (typeof TransitGatewayMulitcastDomainAssociationState)[keyof typeof TransitGatewayMulitcastDomainAssociationState];
+export declare const DynamicRoutingValue: {
+  readonly disable: "disable";
+  readonly enable: "enable";
+};
+export type DynamicRoutingValue =
+  (typeof DynamicRoutingValue)[keyof typeof DynamicRoutingValue];
+export declare const TransitGatewayAttachmentState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly failed: "failed";
+  readonly failing: "failing";
+  readonly initiating: "initiating";
+  readonly initiatingRequest: "initiatingRequest";
+  readonly modifying: "modifying";
+  readonly pending: "pending";
+  readonly pendingAcceptance: "pendingAcceptance";
+  readonly rejected: "rejected";
+  readonly rejecting: "rejecting";
+  readonly rollingBack: "rollingBack";
+};
+export type TransitGatewayAttachmentState =
+  (typeof TransitGatewayAttachmentState)[keyof typeof TransitGatewayAttachmentState];
+export declare const ApplianceModeSupportValue: {
+  readonly disable: "disable";
+  readonly enable: "enable";
+};
+export type ApplianceModeSupportValue =
+  (typeof ApplianceModeSupportValue)[keyof typeof ApplianceModeSupportValue];
+export declare const DnsSupportValue: {
+  readonly disable: "disable";
+  readonly enable: "enable";
+};
+export type DnsSupportValue =
+  (typeof DnsSupportValue)[keyof typeof DnsSupportValue];
+export declare const Ipv6SupportValue: {
+  readonly disable: "disable";
+  readonly enable: "enable";
+};
+export type Ipv6SupportValue =
+  (typeof Ipv6SupportValue)[keyof typeof Ipv6SupportValue];
+export declare const SecurityGroupReferencingSupportValue: {
+  readonly disable: "disable";
+  readonly enable: "enable";
+};
+export type SecurityGroupReferencingSupportValue =
+  (typeof SecurityGroupReferencingSupportValue)[keyof typeof SecurityGroupReferencingSupportValue];
+export declare const VpcPeeringConnectionStateReasonCode: {
+  readonly active: "active";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly expired: "expired";
+  readonly failed: "failed";
+  readonly initiating_request: "initiating-request";
+  readonly pending_acceptance: "pending-acceptance";
+  readonly provisioning: "provisioning";
+  readonly rejected: "rejected";
+};
+export type VpcPeeringConnectionStateReasonCode =
+  (typeof VpcPeeringConnectionStateReasonCode)[keyof typeof VpcPeeringConnectionStateReasonCode];
+export declare const Protocol: {
+  readonly tcp: "tcp";
+  readonly udp: "udp";
+};
+export type Protocol = (typeof Protocol)[keyof typeof Protocol];
+export declare const AccountAttributeName: {
+  readonly default_vpc: "default-vpc";
+  readonly supported_platforms: "supported-platforms";
+};
+export type AccountAttributeName =
+  (typeof AccountAttributeName)[keyof typeof AccountAttributeName];
+export declare const InstanceHealthStatus: {
+  readonly HEALTHY_STATUS: "healthy";
+  readonly UNHEALTHY_STATUS: "unhealthy";
+};
+export type InstanceHealthStatus =
+  (typeof InstanceHealthStatus)[keyof typeof InstanceHealthStatus];
+export declare const VpnTunnelProvisioningStatus: {
+  readonly available: "available";
+  readonly failed: "failed";
+  readonly pending: "pending";
+};
+export type VpnTunnelProvisioningStatus =
+  (typeof VpnTunnelProvisioningStatus)[keyof typeof VpnTunnelProvisioningStatus];
+export declare const ActivityStatus: {
+  readonly ERROR: "error";
+  readonly FULFILLED: "fulfilled";
+  readonly PENDING_FULFILLMENT: "pending_fulfillment";
+  readonly PENDING_TERMINATION: "pending_termination";
+};
+export type ActivityStatus =
+  (typeof ActivityStatus)[keyof typeof ActivityStatus];
+export declare const PrincipalType: {
+  readonly Account: "Account";
+  readonly All: "All";
+  readonly OrganizationUnit: "OrganizationUnit";
+  readonly Role: "Role";
+  readonly Service: "Service";
+  readonly User: "User";
+};
+export type PrincipalType = (typeof PrincipalType)[keyof typeof PrincipalType];
+export declare const DomainType: {
+  readonly standard: "standard";
+  readonly vpc: "vpc";
+};
+export type DomainType = (typeof DomainType)[keyof typeof DomainType];
+export declare const ServiceManaged: {
+  readonly alb: "alb";
+  readonly nlb: "nlb";
+  readonly rds: "rds";
+  readonly rnat: "rnat";
+};
+export type ServiceManaged =
+  (typeof ServiceManaged)[keyof typeof ServiceManaged];
+export declare const AddressAttributeName: {
+  readonly domain_name: "domain-name";
+};
+export type AddressAttributeName =
+  (typeof AddressAttributeName)[keyof typeof AddressAttributeName];
+export declare const AddressFamily: {
+  readonly ipv4: "ipv4";
+  readonly ipv6: "ipv6";
+};
+export type AddressFamily = (typeof AddressFamily)[keyof typeof AddressFamily];
+export declare const AsnAssociationState: {
+  readonly associated: "associated";
+  readonly disassociated: "disassociated";
+  readonly failed_association: "failed-association";
+  readonly failed_disassociation: "failed-disassociation";
+  readonly pending_association: "pending-association";
+  readonly pending_disassociation: "pending-disassociation";
+};
+export type AsnAssociationState =
+  (typeof AsnAssociationState)[keyof typeof AsnAssociationState];
+export declare const ByoipCidrState: {
+  readonly advertised: "advertised";
+  readonly deprovisioned: "deprovisioned";
+  readonly failed_deprovision: "failed-deprovision";
+  readonly failed_provision: "failed-provision";
+  readonly pending_deprovision: "pending-deprovision";
+  readonly pending_provision: "pending-provision";
+  readonly provisioned: "provisioned";
+  readonly provisioned_not_publicly_advertisable: "provisioned-not-publicly-advertisable";
+};
+export type ByoipCidrState =
+  (typeof ByoipCidrState)[keyof typeof ByoipCidrState];
+export declare const Affinity: {
+  readonly default: "default";
+  readonly host: "host";
+};
+export type Affinity = (typeof Affinity)[keyof typeof Affinity];
+export declare const AutoPlacement: {
+  readonly off: "off";
+  readonly on: "on";
+};
+export type AutoPlacement = (typeof AutoPlacement)[keyof typeof AutoPlacement];
+export declare const HostMaintenance: {
+  readonly off: "off";
+  readonly on: "on";
+};
+export type HostMaintenance =
+  (typeof HostMaintenance)[keyof typeof HostMaintenance];
+export declare const HostRecovery: {
+  readonly off: "off";
+  readonly on: "on";
+};
+export type HostRecovery = (typeof HostRecovery)[keyof typeof HostRecovery];
+export declare const IpamPoolAllocationResourceType: {
+  readonly custom: "custom";
+  readonly ec2_public_ipv4_pool: "ec2-public-ipv4-pool";
+  readonly eip: "eip";
+  readonly ipam_pool: "ipam-pool";
+  readonly subnet: "subnet";
+  readonly vpc: "vpc";
+};
+export type IpamPoolAllocationResourceType =
+  (typeof IpamPoolAllocationResourceType)[keyof typeof IpamPoolAllocationResourceType];
+export declare const AllocationState: {
+  readonly available: "available";
+  readonly pending: "pending";
+  readonly permanent_failure: "permanent-failure";
+  readonly released: "released";
+  readonly released_permanent_failure: "released-permanent-failure";
+  readonly under_assessment: "under-assessment";
+};
+export type AllocationState =
+  (typeof AllocationState)[keyof typeof AllocationState];
+export declare const AllocationStrategy: {
+  readonly CAPACITY_OPTIMIZED: "capacityOptimized";
+  readonly CAPACITY_OPTIMIZED_PRIORITIZED: "capacityOptimizedPrioritized";
+  readonly DIVERSIFIED: "diversified";
+  readonly LOWEST_PRICE: "lowestPrice";
+  readonly PRICE_CAPACITY_OPTIMIZED: "priceCapacityOptimized";
+};
+export type AllocationStrategy =
+  (typeof AllocationStrategy)[keyof typeof AllocationStrategy];
+export declare const AllocationType: {
+  readonly future: "future";
+  readonly used: "used";
+};
+export type AllocationType =
+  (typeof AllocationType)[keyof typeof AllocationType];
+export declare const AllowedImagesSettingsDisabledState: {
+  readonly disabled: "disabled";
+};
+export type AllowedImagesSettingsDisabledState =
+  (typeof AllowedImagesSettingsDisabledState)[keyof typeof AllowedImagesSettingsDisabledState];
+export declare const AllowedImagesSettingsEnabledState: {
+  readonly audit_mode: "audit-mode";
+  readonly enabled: "enabled";
+};
+export type AllowedImagesSettingsEnabledState =
+  (typeof AllowedImagesSettingsEnabledState)[keyof typeof AllowedImagesSettingsEnabledState];
+export declare const AllowsMultipleInstanceTypes: {
+  readonly off: "off";
+  readonly on: "on";
+};
+export type AllowsMultipleInstanceTypes =
+  (typeof AllowsMultipleInstanceTypes)[keyof typeof AllowsMultipleInstanceTypes];
+export declare const NatGatewayAddressStatus: {
+  readonly ASSIGNING: "assigning";
+  readonly ASSOCIATING: "associating";
+  readonly DISASSOCIATING: "disassociating";
+  readonly FAILED: "failed";
+  readonly SUCCEEDED: "succeeded";
+  readonly UNASSIGNING: "unassigning";
+};
+export type NatGatewayAddressStatus =
+  (typeof NatGatewayAddressStatus)[keyof typeof NatGatewayAddressStatus];
+export declare const AssociationStatusCode: {
+  readonly associated: "associated";
+  readonly associating: "associating";
+  readonly association_failed: "association-failed";
+  readonly disassociated: "disassociated";
+  readonly disassociating: "disassociating";
+};
+export type AssociationStatusCode =
+  (typeof AssociationStatusCode)[keyof typeof AssociationStatusCode];
+export declare const IamInstanceProfileAssociationState: {
+  readonly ASSOCIATED: "associated";
+  readonly ASSOCIATING: "associating";
+  readonly DISASSOCIATED: "disassociated";
+  readonly DISASSOCIATING: "disassociating";
+};
+export type IamInstanceProfileAssociationState =
+  (typeof IamInstanceProfileAssociationState)[keyof typeof IamInstanceProfileAssociationState];
+export declare const InstanceEventWindowState: {
+  readonly active: "active";
+  readonly creating: "creating";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+};
+export type InstanceEventWindowState =
+  (typeof InstanceEventWindowState)[keyof typeof InstanceEventWindowState];
+export declare const WeekDay: {
+  readonly friday: "friday";
+  readonly monday: "monday";
+  readonly saturday: "saturday";
+  readonly sunday: "sunday";
+  readonly thursday: "thursday";
+  readonly tuesday: "tuesday";
+  readonly wednesday: "wednesday";
+};
+export type WeekDay = (typeof WeekDay)[keyof typeof WeekDay];
+export declare const IpamAssociatedResourceDiscoveryStatus: {
+  readonly ACTIVE: "active";
+  readonly NOT_FOUND: "not-found";
+};
+export type IpamAssociatedResourceDiscoveryStatus =
+  (typeof IpamAssociatedResourceDiscoveryStatus)[keyof typeof IpamAssociatedResourceDiscoveryStatus];
+export declare const IpamResourceDiscoveryAssociationState: {
+  readonly ASSOCIATE_COMPLETE: "associate-complete";
+  readonly ASSOCIATE_FAILED: "associate-failed";
+  readonly ASSOCIATE_IN_PROGRESS: "associate-in-progress";
+  readonly DISASSOCIATE_COMPLETE: "disassociate-complete";
+  readonly DISASSOCIATE_FAILED: "disassociate-failed";
+  readonly DISASSOCIATE_IN_PROGRESS: "disassociate-in-progress";
+  readonly ISOLATE_COMPLETE: "isolate-complete";
+  readonly ISOLATE_IN_PROGRESS: "isolate-in-progress";
+  readonly RESTORE_IN_PROGRESS: "restore-in-progress";
+};
+export type IpamResourceDiscoveryAssociationState =
+  (typeof IpamResourceDiscoveryAssociationState)[keyof typeof IpamResourceDiscoveryAssociationState];
+export declare const RouteServerAssociationState: {
+  readonly ASSOCIATED: "associated";
+  readonly ASSOCIATING: "associating";
+  readonly DISASSOCIATING: "disassociating";
+};
+export type RouteServerAssociationState =
+  (typeof RouteServerAssociationState)[keyof typeof RouteServerAssociationState];
+export declare const RouteTableAssociationStateCode: {
+  readonly associated: "associated";
+  readonly associating: "associating";
+  readonly disassociated: "disassociated";
+  readonly disassociating: "disassociating";
+  readonly failed: "failed";
+};
+export type RouteTableAssociationStateCode =
+  (typeof RouteTableAssociationStateCode)[keyof typeof RouteTableAssociationStateCode];
+export declare const SecurityGroupVpcAssociationState: {
+  readonly associated: "associated";
+  readonly associating: "associating";
+  readonly association_failed: "association-failed";
+  readonly disassociated: "disassociated";
+  readonly disassociating: "disassociating";
+  readonly disassociation_failed: "disassociation-failed";
+};
+export type SecurityGroupVpcAssociationState =
+  (typeof SecurityGroupVpcAssociationState)[keyof typeof SecurityGroupVpcAssociationState];
+export declare const IpSource: {
+  readonly amazon: "amazon";
+  readonly byoip: "byoip";
+  readonly none: "none";
+};
+export type IpSource = (typeof IpSource)[keyof typeof IpSource];
+export declare const Ipv6AddressAttribute: {
+  readonly private: "private";
+  readonly public: "public";
+};
+export type Ipv6AddressAttribute =
+  (typeof Ipv6AddressAttribute)[keyof typeof Ipv6AddressAttribute];
+export declare const SubnetCidrBlockStateCode: {
+  readonly associated: "associated";
+  readonly associating: "associating";
+  readonly disassociated: "disassociated";
+  readonly disassociating: "disassociating";
+  readonly failed: "failed";
+  readonly failing: "failing";
+};
+export type SubnetCidrBlockStateCode =
+  (typeof SubnetCidrBlockStateCode)[keyof typeof SubnetCidrBlockStateCode];
+export declare const TransitGatewayAssociationState: {
+  readonly associated: "associated";
+  readonly associating: "associating";
+  readonly disassociated: "disassociated";
+  readonly disassociating: "disassociating";
+};
+export type TransitGatewayAssociationState =
+  (typeof TransitGatewayAssociationState)[keyof typeof TransitGatewayAssociationState];
+export declare const InterfaceProtocolType: {
+  readonly GRE: "GRE";
+  readonly VLAN: "VLAN";
+};
+export type InterfaceProtocolType =
+  (typeof InterfaceProtocolType)[keyof typeof InterfaceProtocolType];
+export declare const VpcCidrBlockStateCode: {
+  readonly associated: "associated";
+  readonly associating: "associating";
+  readonly disassociated: "disassociated";
+  readonly disassociating: "disassociating";
+  readonly failed: "failed";
+  readonly failing: "failing";
+};
+export type VpcCidrBlockStateCode =
+  (typeof VpcCidrBlockStateCode)[keyof typeof VpcCidrBlockStateCode];
+export declare const DeviceTrustProviderType: {
+  readonly crowdstrike: "crowdstrike";
+  readonly jamf: "jamf";
+  readonly jumpcloud: "jumpcloud";
+};
+export type DeviceTrustProviderType =
+  (typeof DeviceTrustProviderType)[keyof typeof DeviceTrustProviderType];
+export declare const TrustProviderType: {
+  readonly device: "device";
+  readonly user: "user";
+};
+export type TrustProviderType =
+  (typeof TrustProviderType)[keyof typeof TrustProviderType];
+export declare const UserTrustProviderType: {
+  readonly iam_identity_center: "iam-identity-center";
+  readonly oidc: "oidc";
+};
+export type UserTrustProviderType =
+  (typeof UserTrustProviderType)[keyof typeof UserTrustProviderType];
+export declare const VolumeAttachmentState: {
+  readonly attached: "attached";
+  readonly attaching: "attaching";
+  readonly busy: "busy";
+  readonly detached: "detached";
+  readonly detaching: "detaching";
+};
+export type VolumeAttachmentState =
+  (typeof VolumeAttachmentState)[keyof typeof VolumeAttachmentState];
+export declare const AttachmentStatus: {
+  readonly attached: "attached";
+  readonly attaching: "attaching";
+  readonly detached: "detached";
+  readonly detaching: "detaching";
+};
+export type AttachmentStatus =
+  (typeof AttachmentStatus)[keyof typeof AttachmentStatus];
+export declare const ClientVpnAuthorizationRuleStatusCode: {
+  readonly active: "active";
+  readonly authorizing: "authorizing";
+  readonly failed: "failed";
+  readonly revoking: "revoking";
+};
+export type ClientVpnAuthorizationRuleStatusCode =
+  (typeof ClientVpnAuthorizationRuleStatusCode)[keyof typeof ClientVpnAuthorizationRuleStatusCode];
+export declare const BundleTaskState: {
+  readonly bundling: "bundling";
+  readonly cancelling: "cancelling";
+  readonly complete: "complete";
+  readonly failed: "failed";
+  readonly pending: "pending";
+  readonly storing: "storing";
+  readonly waiting_for_shutdown: "waiting-for-shutdown";
+};
+export type BundleTaskState =
+  (typeof BundleTaskState)[keyof typeof BundleTaskState];
+export declare const CapacityReservationFleetState: {
+  readonly ACTIVE: "active";
+  readonly CANCELLED: "cancelled";
+  readonly CANCELLING: "cancelling";
+  readonly EXPIRED: "expired";
+  readonly EXPIRING: "expiring";
+  readonly FAILED: "failed";
+  readonly MODIFYING: "modifying";
+  readonly PARTIALLY_FULFILLED: "partially_fulfilled";
+  readonly SUBMITTED: "submitted";
+};
+export type CapacityReservationFleetState =
+  (typeof CapacityReservationFleetState)[keyof typeof CapacityReservationFleetState];
+export declare const ListingState: {
+  readonly available: "available";
+  readonly cancelled: "cancelled";
+  readonly pending: "pending";
+  readonly sold: "sold";
+};
+export type ListingState = (typeof ListingState)[keyof typeof ListingState];
+export declare const CurrencyCodeValues: {
+  readonly USD: "USD";
+};
+export type CurrencyCodeValues =
+  (typeof CurrencyCodeValues)[keyof typeof CurrencyCodeValues];
+export declare const ListingStatus: {
+  readonly active: "active";
+  readonly cancelled: "cancelled";
+  readonly closed: "closed";
+  readonly pending: "pending";
+};
+export type ListingStatus = (typeof ListingStatus)[keyof typeof ListingStatus];
+export declare const BatchState: {
+  readonly ACTIVE: "active";
+  readonly CANCELLED: "cancelled";
+  readonly CANCELLED_RUNNING: "cancelled_running";
+  readonly CANCELLED_TERMINATING_INSTANCES: "cancelled_terminating";
+  readonly FAILED: "failed";
+  readonly MODIFYING: "modifying";
+  readonly SUBMITTED: "submitted";
+};
+export type BatchState = (typeof BatchState)[keyof typeof BatchState];
+export declare const CancelBatchErrorCode: {
+  readonly FLEET_REQUEST_ID_DOES_NOT_EXIST: "fleetRequestIdDoesNotExist";
+  readonly FLEET_REQUEST_ID_MALFORMED: "fleetRequestIdMalformed";
+  readonly FLEET_REQUEST_NOT_IN_CANCELLABLE_STATE: "fleetRequestNotInCancellableState";
+  readonly UNEXPECTED_ERROR: "unexpectedError";
+};
+export type CancelBatchErrorCode =
+  (typeof CancelBatchErrorCode)[keyof typeof CancelBatchErrorCode];
+export declare const CancelSpotInstanceRequestState: {
+  readonly active: "active";
+  readonly cancelled: "cancelled";
+  readonly closed: "closed";
+  readonly completed: "completed";
+  readonly open: "open";
+};
+export type CancelSpotInstanceRequestState =
+  (typeof CancelSpotInstanceRequestState)[keyof typeof CancelSpotInstanceRequestState];
+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 declare const SSEType: {
+  readonly none: "none";
+  readonly sse_ebs: "sse-ebs";
+  readonly sse_kms: "sse-kms";
+};
+export type SSEType = (typeof SSEType)[keyof typeof SSEType];
+export declare const VolumeState: {
+  readonly available: "available";
+  readonly creating: "creating";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly error: "error";
+  readonly in_use: "in-use";
+};
+export type VolumeState = (typeof VolumeState)[keyof typeof VolumeState];
+export declare const OutputFormat: {
+  readonly CSV: "csv";
+  readonly PARQUET: "parquet";
+};
+export type OutputFormat = (typeof OutputFormat)[keyof typeof OutputFormat];
+export declare const Schedule: {
+  readonly HOURLY: "hourly";
+};
+export type Schedule = (typeof Schedule)[keyof typeof Schedule];
+export declare const CapacityReservationDeliveryPreference: {
+  readonly FIXED: "fixed";
+  readonly INCREMENTAL: "incremental";
+};
+export type CapacityReservationDeliveryPreference =
+  (typeof CapacityReservationDeliveryPreference)[keyof typeof CapacityReservationDeliveryPreference];
+export declare const EndDateType: {
+  readonly limited: "limited";
+  readonly unlimited: "unlimited";
+};
+export type EndDateType = (typeof EndDateType)[keyof typeof EndDateType];
+export declare const InstanceMatchCriteria: {
+  readonly open: "open";
+  readonly targeted: "targeted";
+};
+export type InstanceMatchCriteria =
+  (typeof InstanceMatchCriteria)[keyof typeof InstanceMatchCriteria];
+export declare const CapacityReservationInstancePlatform: {
+  readonly LINUX_UNIX: "Linux/UNIX";
+  readonly LINUX_WITH_SQL_SERVER_ENTERPRISE: "Linux with SQL Server Enterprise";
+  readonly LINUX_WITH_SQL_SERVER_STANDARD: "Linux with SQL Server Standard";
+  readonly LINUX_WITH_SQL_SERVER_WEB: "Linux with SQL Server Web";
+  readonly RED_HAT_ENTERPRISE_LINUX: "Red Hat Enterprise Linux";
+  readonly RHEL_WITH_HA: "RHEL with HA";
+  readonly RHEL_WITH_HA_AND_SQL_SERVER_ENTERPRISE: "RHEL with HA and SQL Server Enterprise";
+  readonly RHEL_WITH_HA_AND_SQL_SERVER_STANDARD: "RHEL with HA and SQL Server Standard";
+  readonly RHEL_WITH_SQL_SERVER_ENTERPRISE: "RHEL with SQL Server Enterprise";
+  readonly RHEL_WITH_SQL_SERVER_STANDARD: "RHEL with SQL Server Standard";
+  readonly RHEL_WITH_SQL_SERVER_WEB: "RHEL with SQL Server Web";
+  readonly SUSE_LINUX: "SUSE Linux";
+  readonly UBUNTU_PRO_LINUX: "Ubuntu Pro";
+  readonly WINDOWS: "Windows";
+  readonly WINDOWS_WITH_SQL_SERVER: "Windows with SQL Server";
+  readonly WINDOWS_WITH_SQL_SERVER_ENTERPRISE: "Windows with SQL Server Enterprise";
+  readonly WINDOWS_WITH_SQL_SERVER_STANDARD: "Windows with SQL Server Standard";
+  readonly WINDOWS_WITH_SQL_SERVER_WEB: "Windows with SQL Server Web";
+};
+export type CapacityReservationInstancePlatform =
+  (typeof CapacityReservationInstancePlatform)[keyof typeof CapacityReservationInstancePlatform];
+export declare const CapacityReservationTenancy: {
+  readonly dedicated: "dedicated";
+  readonly default: "default";
+};
+export type CapacityReservationTenancy =
+  (typeof CapacityReservationTenancy)[keyof typeof CapacityReservationTenancy];
+export declare const CapacityReservationType: {
+  readonly CAPACITY_BLOCK: "capacity-block";
+  readonly DEFAULT: "default";
+};
+export type CapacityReservationType =
+  (typeof CapacityReservationType)[keyof typeof CapacityReservationType];
+export declare const CapacityReservationState: {
+  readonly active: "active";
+  readonly assessing: "assessing";
+  readonly cancelled: "cancelled";
+  readonly delayed: "delayed";
+  readonly expired: "expired";
+  readonly failed: "failed";
+  readonly payment_failed: "payment-failed";
+  readonly payment_pending: "payment-pending";
+  readonly pending: "pending";
+  readonly scheduled: "scheduled";
+  readonly unavailable: "unavailable";
+  readonly unsupported: "unsupported";
+};
+export type CapacityReservationState =
+  (typeof CapacityReservationState)[keyof typeof CapacityReservationState];
+export declare const FleetInstanceMatchCriteria: {
+  readonly open: "open";
+};
+export type FleetInstanceMatchCriteria =
+  (typeof FleetInstanceMatchCriteria)[keyof typeof FleetInstanceMatchCriteria];
+export declare const _InstanceType: {
+  readonly a1_2xlarge: "a1.2xlarge";
+  readonly a1_4xlarge: "a1.4xlarge";
+  readonly a1_large: "a1.large";
+  readonly a1_medium: "a1.medium";
+  readonly a1_metal: "a1.metal";
+  readonly a1_xlarge: "a1.xlarge";
+  readonly c1_medium: "c1.medium";
+  readonly c1_xlarge: "c1.xlarge";
+  readonly c3_2xlarge: "c3.2xlarge";
+  readonly c3_4xlarge: "c3.4xlarge";
+  readonly c3_8xlarge: "c3.8xlarge";
+  readonly c3_large: "c3.large";
+  readonly c3_xlarge: "c3.xlarge";
+  readonly c4_2xlarge: "c4.2xlarge";
+  readonly c4_4xlarge: "c4.4xlarge";
+  readonly c4_8xlarge: "c4.8xlarge";
+  readonly c4_large: "c4.large";
+  readonly c4_xlarge: "c4.xlarge";
+  readonly c5_12xlarge: "c5.12xlarge";
+  readonly c5_18xlarge: "c5.18xlarge";
+  readonly c5_24xlarge: "c5.24xlarge";
+  readonly c5_2xlarge: "c5.2xlarge";
+  readonly c5_4xlarge: "c5.4xlarge";
+  readonly c5_9xlarge: "c5.9xlarge";
+  readonly c5_large: "c5.large";
+  readonly c5_metal: "c5.metal";
+  readonly c5_xlarge: "c5.xlarge";
+  readonly c5a_12xlarge: "c5a.12xlarge";
+  readonly c5a_16xlarge: "c5a.16xlarge";
+  readonly c5a_24xlarge: "c5a.24xlarge";
+  readonly c5a_2xlarge: "c5a.2xlarge";
+  readonly c5a_4xlarge: "c5a.4xlarge";
+  readonly c5a_8xlarge: "c5a.8xlarge";
+  readonly c5a_large: "c5a.large";
+  readonly c5a_xlarge: "c5a.xlarge";
+  readonly c5ad_12xlarge: "c5ad.12xlarge";
+  readonly c5ad_16xlarge: "c5ad.16xlarge";
+  readonly c5ad_24xlarge: "c5ad.24xlarge";
+  readonly c5ad_2xlarge: "c5ad.2xlarge";
+  readonly c5ad_4xlarge: "c5ad.4xlarge";
+  readonly c5ad_8xlarge: "c5ad.8xlarge";
+  readonly c5ad_large: "c5ad.large";
+  readonly c5ad_xlarge: "c5ad.xlarge";
+  readonly c5d_12xlarge: "c5d.12xlarge";
+  readonly c5d_18xlarge: "c5d.18xlarge";
+  readonly c5d_24xlarge: "c5d.24xlarge";
+  readonly c5d_2xlarge: "c5d.2xlarge";
+  readonly c5d_4xlarge: "c5d.4xlarge";
+  readonly c5d_9xlarge: "c5d.9xlarge";
+  readonly c5d_large: "c5d.large";
+  readonly c5d_metal: "c5d.metal";
+  readonly c5d_xlarge: "c5d.xlarge";
+  readonly c5n_18xlarge: "c5n.18xlarge";
+  readonly c5n_2xlarge: "c5n.2xlarge";
+  readonly c5n_4xlarge: "c5n.4xlarge";
+  readonly c5n_9xlarge: "c5n.9xlarge";
+  readonly c5n_large: "c5n.large";
+  readonly c5n_metal: "c5n.metal";
+  readonly c5n_xlarge: "c5n.xlarge";
+  readonly c6a_12xlarge: "c6a.12xlarge";
+  readonly c6a_16xlarge: "c6a.16xlarge";
+  readonly c6a_24xlarge: "c6a.24xlarge";
+  readonly c6a_2xlarge: "c6a.2xlarge";
+  readonly c6a_32xlarge: "c6a.32xlarge";
+  readonly c6a_48xlarge: "c6a.48xlarge";
+  readonly c6a_4xlarge: "c6a.4xlarge";
+  readonly c6a_8xlarge: "c6a.8xlarge";
+  readonly c6a_large: "c6a.large";
+  readonly c6a_metal: "c6a.metal";
+  readonly c6a_xlarge: "c6a.xlarge";
+  readonly c6g_12xlarge: "c6g.12xlarge";
+  readonly c6g_16xlarge: "c6g.16xlarge";
+  readonly c6g_2xlarge: "c6g.2xlarge";
+  readonly c6g_4xlarge: "c6g.4xlarge";
+  readonly c6g_8xlarge: "c6g.8xlarge";
+  readonly c6g_large: "c6g.large";
+  readonly c6g_medium: "c6g.medium";
+  readonly c6g_metal: "c6g.metal";
+  readonly c6g_xlarge: "c6g.xlarge";
+  readonly c6gd_12xlarge: "c6gd.12xlarge";
+  readonly c6gd_16xlarge: "c6gd.16xlarge";
+  readonly c6gd_2xlarge: "c6gd.2xlarge";
+  readonly c6gd_4xlarge: "c6gd.4xlarge";
+  readonly c6gd_8xlarge: "c6gd.8xlarge";
+  readonly c6gd_large: "c6gd.large";
+  readonly c6gd_medium: "c6gd.medium";
+  readonly c6gd_metal: "c6gd.metal";
+  readonly c6gd_xlarge: "c6gd.xlarge";
+  readonly c6gn_12xlarge: "c6gn.12xlarge";
+  readonly c6gn_16xlarge: "c6gn.16xlarge";
+  readonly c6gn_2xlarge: "c6gn.2xlarge";
+  readonly c6gn_4xlarge: "c6gn.4xlarge";
+  readonly c6gn_8xlarge: "c6gn.8xlarge";
+  readonly c6gn_large: "c6gn.large";
+  readonly c6gn_medium: "c6gn.medium";
+  readonly c6gn_xlarge: "c6gn.xlarge";
+  readonly c6i_12xlarge: "c6i.12xlarge";
+  readonly c6i_16xlarge: "c6i.16xlarge";
+  readonly c6i_24xlarge: "c6i.24xlarge";
+  readonly c6i_2xlarge: "c6i.2xlarge";
+  readonly c6i_32xlarge: "c6i.32xlarge";
+  readonly c6i_4xlarge: "c6i.4xlarge";
+  readonly c6i_8xlarge: "c6i.8xlarge";
+  readonly c6i_large: "c6i.large";
+  readonly c6i_metal: "c6i.metal";
+  readonly c6i_xlarge: "c6i.xlarge";
+  readonly c6id_12xlarge: "c6id.12xlarge";
+  readonly c6id_16xlarge: "c6id.16xlarge";
+  readonly c6id_24xlarge: "c6id.24xlarge";
+  readonly c6id_2xlarge: "c6id.2xlarge";
+  readonly c6id_32xlarge: "c6id.32xlarge";
+  readonly c6id_4xlarge: "c6id.4xlarge";
+  readonly c6id_8xlarge: "c6id.8xlarge";
+  readonly c6id_large: "c6id.large";
+  readonly c6id_metal: "c6id.metal";
+  readonly c6id_xlarge: "c6id.xlarge";
+  readonly c6in_12xlarge: "c6in.12xlarge";
+  readonly c6in_16xlarge: "c6in.16xlarge";
+  readonly c6in_24xlarge: "c6in.24xlarge";
+  readonly c6in_2xlarge: "c6in.2xlarge";
+  readonly c6in_32xlarge: "c6in.32xlarge";
+  readonly c6in_4xlarge: "c6in.4xlarge";
+  readonly c6in_8xlarge: "c6in.8xlarge";
+  readonly c6in_large: "c6in.large";
+  readonly c6in_metal: "c6in.metal";
+  readonly c6in_xlarge: "c6in.xlarge";
+  readonly c7a_12xlarge: "c7a.12xlarge";
+  readonly c7a_16xlarge: "c7a.16xlarge";
+  readonly c7a_24xlarge: "c7a.24xlarge";
+  readonly c7a_2xlarge: "c7a.2xlarge";
+  readonly c7a_32xlarge: "c7a.32xlarge";
+  readonly c7a_48xlarge: "c7a.48xlarge";
+  readonly c7a_4xlarge: "c7a.4xlarge";
+  readonly c7a_8xlarge: "c7a.8xlarge";
+  readonly c7a_large: "c7a.large";
+  readonly c7a_medium: "c7a.medium";
+  readonly c7a_metal_48xl: "c7a.metal-48xl";
+  readonly c7a_xlarge: "c7a.xlarge";
+  readonly c7g_12xlarge: "c7g.12xlarge";
+  readonly c7g_16xlarge: "c7g.16xlarge";
+  readonly c7g_2xlarge: "c7g.2xlarge";
+  readonly c7g_4xlarge: "c7g.4xlarge";
+  readonly c7g_8xlarge: "c7g.8xlarge";
+  readonly c7g_large: "c7g.large";
+  readonly c7g_medium: "c7g.medium";
+  readonly c7g_metal: "c7g.metal";
+  readonly c7g_xlarge: "c7g.xlarge";
+  readonly c7gd_12xlarge: "c7gd.12xlarge";
+  readonly c7gd_16xlarge: "c7gd.16xlarge";
+  readonly c7gd_2xlarge: "c7gd.2xlarge";
+  readonly c7gd_4xlarge: "c7gd.4xlarge";
+  readonly c7gd_8xlarge: "c7gd.8xlarge";
+  readonly c7gd_large: "c7gd.large";
+  readonly c7gd_medium: "c7gd.medium";
+  readonly c7gd_metal: "c7gd.metal";
+  readonly c7gd_xlarge: "c7gd.xlarge";
+  readonly c7gn_12xlarge: "c7gn.12xlarge";
+  readonly c7gn_16xlarge: "c7gn.16xlarge";
+  readonly c7gn_2xlarge: "c7gn.2xlarge";
+  readonly c7gn_4xlarge: "c7gn.4xlarge";
+  readonly c7gn_8xlarge: "c7gn.8xlarge";
+  readonly c7gn_large: "c7gn.large";
+  readonly c7gn_medium: "c7gn.medium";
+  readonly c7gn_metal: "c7gn.metal";
+  readonly c7gn_xlarge: "c7gn.xlarge";
+  readonly c7i_12xlarge: "c7i.12xlarge";
+  readonly c7i_16xlarge: "c7i.16xlarge";
+  readonly c7i_24xlarge: "c7i.24xlarge";
+  readonly c7i_2xlarge: "c7i.2xlarge";
+  readonly c7i_48xlarge: "c7i.48xlarge";
+  readonly c7i_4xlarge: "c7i.4xlarge";
+  readonly c7i_8xlarge: "c7i.8xlarge";
+  readonly c7i_flex_12xlarge: "c7i-flex.12xlarge";
+  readonly c7i_flex_16xlarge: "c7i-flex.16xlarge";
+  readonly c7i_flex_2xlarge: "c7i-flex.2xlarge";
+  readonly c7i_flex_4xlarge: "c7i-flex.4xlarge";
+  readonly c7i_flex_8xlarge: "c7i-flex.8xlarge";
+  readonly c7i_flex_large: "c7i-flex.large";
+  readonly c7i_flex_xlarge: "c7i-flex.xlarge";
+  readonly c7i_large: "c7i.large";
+  readonly c7i_metal_24xl: "c7i.metal-24xl";
+  readonly c7i_metal_48xl: "c7i.metal-48xl";
+  readonly c7i_xlarge: "c7i.xlarge";
+  readonly c8g_12xlarge: "c8g.12xlarge";
+  readonly c8g_16xlarge: "c8g.16xlarge";
+  readonly c8g_24xlarge: "c8g.24xlarge";
+  readonly c8g_2xlarge: "c8g.2xlarge";
+  readonly c8g_48xlarge: "c8g.48xlarge";
+  readonly c8g_4xlarge: "c8g.4xlarge";
+  readonly c8g_8xlarge: "c8g.8xlarge";
+  readonly c8g_large: "c8g.large";
+  readonly c8g_medium: "c8g.medium";
+  readonly c8g_metal_24xl: "c8g.metal-24xl";
+  readonly c8g_metal_48xl: "c8g.metal-48xl";
+  readonly c8g_xlarge: "c8g.xlarge";
+  readonly c8gd_12xlarge: "c8gd.12xlarge";
+  readonly c8gd_16xlarge: "c8gd.16xlarge";
+  readonly c8gd_24xlarge: "c8gd.24xlarge";
+  readonly c8gd_2xlarge: "c8gd.2xlarge";
+  readonly c8gd_48xlarge: "c8gd.48xlarge";
+  readonly c8gd_4xlarge: "c8gd.4xlarge";
+  readonly c8gd_8xlarge: "c8gd.8xlarge";
+  readonly c8gd_large: "c8gd.large";
+  readonly c8gd_medium: "c8gd.medium";
+  readonly c8gd_metal_24xl: "c8gd.metal-24xl";
+  readonly c8gd_metal_48xl: "c8gd.metal-48xl";
+  readonly c8gd_xlarge: "c8gd.xlarge";
+  readonly c8gn_12xlarge: "c8gn.12xlarge";
+  readonly c8gn_16xlarge: "c8gn.16xlarge";
+  readonly c8gn_24xlarge: "c8gn.24xlarge";
+  readonly c8gn_2xlarge: "c8gn.2xlarge";
+  readonly c8gn_48xlarge: "c8gn.48xlarge";
+  readonly c8gn_4xlarge: "c8gn.4xlarge";
+  readonly c8gn_8xlarge: "c8gn.8xlarge";
+  readonly c8gn_large: "c8gn.large";
+  readonly c8gn_medium: "c8gn.medium";
+  readonly c8gn_metal_24xl: "c8gn.metal-24xl";
+  readonly c8gn_metal_48xl: "c8gn.metal-48xl";
+  readonly c8gn_xlarge: "c8gn.xlarge";
+  readonly c8i_12xlarge: "c8i.12xlarge";
+  readonly c8i_16xlarge: "c8i.16xlarge";
+  readonly c8i_24xlarge: "c8i.24xlarge";
+  readonly c8i_2xlarge: "c8i.2xlarge";
+  readonly c8i_32xlarge: "c8i.32xlarge";
+  readonly c8i_48xlarge: "c8i.48xlarge";
+  readonly c8i_4xlarge: "c8i.4xlarge";
+  readonly c8i_8xlarge: "c8i.8xlarge";
+  readonly c8i_96xlarge: "c8i.96xlarge";
+  readonly c8i_flex_12xlarge: "c8i-flex.12xlarge";
+  readonly c8i_flex_16xlarge: "c8i-flex.16xlarge";
+  readonly c8i_flex_2xlarge: "c8i-flex.2xlarge";
+  readonly c8i_flex_4xlarge: "c8i-flex.4xlarge";
+  readonly c8i_flex_8xlarge: "c8i-flex.8xlarge";
+  readonly c8i_flex_large: "c8i-flex.large";
+  readonly c8i_flex_xlarge: "c8i-flex.xlarge";
+  readonly c8i_large: "c8i.large";
+  readonly c8i_metal_48xl: "c8i.metal-48xl";
+  readonly c8i_metal_96xl: "c8i.metal-96xl";
+  readonly c8i_xlarge: "c8i.xlarge";
+  readonly cc1_4xlarge: "cc1.4xlarge";
+  readonly cc2_8xlarge: "cc2.8xlarge";
+  readonly cg1_4xlarge: "cg1.4xlarge";
+  readonly cr1_8xlarge: "cr1.8xlarge";
+  readonly d2_2xlarge: "d2.2xlarge";
+  readonly d2_4xlarge: "d2.4xlarge";
+  readonly d2_8xlarge: "d2.8xlarge";
+  readonly d2_xlarge: "d2.xlarge";
+  readonly d3_2xlarge: "d3.2xlarge";
+  readonly d3_4xlarge: "d3.4xlarge";
+  readonly d3_8xlarge: "d3.8xlarge";
+  readonly d3_xlarge: "d3.xlarge";
+  readonly d3en_12xlarge: "d3en.12xlarge";
+  readonly d3en_2xlarge: "d3en.2xlarge";
+  readonly d3en_4xlarge: "d3en.4xlarge";
+  readonly d3en_6xlarge: "d3en.6xlarge";
+  readonly d3en_8xlarge: "d3en.8xlarge";
+  readonly d3en_xlarge: "d3en.xlarge";
+  readonly dl1_24xlarge: "dl1.24xlarge";
+  readonly dl2q_24xlarge: "dl2q.24xlarge";
+  readonly f1_16xlarge: "f1.16xlarge";
+  readonly f1_2xlarge: "f1.2xlarge";
+  readonly f1_4xlarge: "f1.4xlarge";
+  readonly f2_12xlarge: "f2.12xlarge";
+  readonly f2_48xlarge: "f2.48xlarge";
+  readonly f2_6xlarge: "f2.6xlarge";
+  readonly g2_2xlarge: "g2.2xlarge";
+  readonly g2_8xlarge: "g2.8xlarge";
+  readonly g3_16xlarge: "g3.16xlarge";
+  readonly g3_4xlarge: "g3.4xlarge";
+  readonly g3_8xlarge: "g3.8xlarge";
+  readonly g3s_xlarge: "g3s.xlarge";
+  readonly g4ad_16xlarge: "g4ad.16xlarge";
+  readonly g4ad_2xlarge: "g4ad.2xlarge";
+  readonly g4ad_4xlarge: "g4ad.4xlarge";
+  readonly g4ad_8xlarge: "g4ad.8xlarge";
+  readonly g4ad_xlarge: "g4ad.xlarge";
+  readonly g4dn_12xlarge: "g4dn.12xlarge";
+  readonly g4dn_16xlarge: "g4dn.16xlarge";
+  readonly g4dn_2xlarge: "g4dn.2xlarge";
+  readonly g4dn_4xlarge: "g4dn.4xlarge";
+  readonly g4dn_8xlarge: "g4dn.8xlarge";
+  readonly g4dn_metal: "g4dn.metal";
+  readonly g4dn_xlarge: "g4dn.xlarge";
+  readonly g5_12xlarge: "g5.12xlarge";
+  readonly g5_16xlarge: "g5.16xlarge";
+  readonly g5_24xlarge: "g5.24xlarge";
+  readonly g5_2xlarge: "g5.2xlarge";
+  readonly g5_48xlarge: "g5.48xlarge";
+  readonly g5_4xlarge: "g5.4xlarge";
+  readonly g5_8xlarge: "g5.8xlarge";
+  readonly g5_xlarge: "g5.xlarge";
+  readonly g5g_16xlarge: "g5g.16xlarge";
+  readonly g5g_2xlarge: "g5g.2xlarge";
+  readonly g5g_4xlarge: "g5g.4xlarge";
+  readonly g5g_8xlarge: "g5g.8xlarge";
+  readonly g5g_metal: "g5g.metal";
+  readonly g5g_xlarge: "g5g.xlarge";
+  readonly g6_12xlarge: "g6.12xlarge";
+  readonly g6_16xlarge: "g6.16xlarge";
+  readonly g6_24xlarge: "g6.24xlarge";
+  readonly g6_2xlarge: "g6.2xlarge";
+  readonly g6_48xlarge: "g6.48xlarge";
+  readonly g6_4xlarge: "g6.4xlarge";
+  readonly g6_8xlarge: "g6.8xlarge";
+  readonly g6_xlarge: "g6.xlarge";
+  readonly g6e_12xlarge: "g6e.12xlarge";
+  readonly g6e_16xlarge: "g6e.16xlarge";
+  readonly g6e_24xlarge: "g6e.24xlarge";
+  readonly g6e_2xlarge: "g6e.2xlarge";
+  readonly g6e_48xlarge: "g6e.48xlarge";
+  readonly g6e_4xlarge: "g6e.4xlarge";
+  readonly g6e_8xlarge: "g6e.8xlarge";
+  readonly g6e_xlarge: "g6e.xlarge";
+  readonly g6f_2xlarge: "g6f.2xlarge";
+  readonly g6f_4xlarge: "g6f.4xlarge";
+  readonly g6f_large: "g6f.large";
+  readonly g6f_xlarge: "g6f.xlarge";
+  readonly gr6_4xlarge: "gr6.4xlarge";
+  readonly gr6_8xlarge: "gr6.8xlarge";
+  readonly gr6f_4xlarge: "gr6f.4xlarge";
+  readonly h1_16xlarge: "h1.16xlarge";
+  readonly h1_2xlarge: "h1.2xlarge";
+  readonly h1_4xlarge: "h1.4xlarge";
+  readonly h1_8xlarge: "h1.8xlarge";
+  readonly hi1_4xlarge: "hi1.4xlarge";
+  readonly hpc6a_48xlarge: "hpc6a.48xlarge";
+  readonly hpc6id_32xlarge: "hpc6id.32xlarge";
+  readonly hpc7a_12xlarge: "hpc7a.12xlarge";
+  readonly hpc7a_24xlarge: "hpc7a.24xlarge";
+  readonly hpc7a_48xlarge: "hpc7a.48xlarge";
+  readonly hpc7a_96xlarge: "hpc7a.96xlarge";
+  readonly hpc7g_16xlarge: "hpc7g.16xlarge";
+  readonly hpc7g_4xlarge: "hpc7g.4xlarge";
+  readonly hpc7g_8xlarge: "hpc7g.8xlarge";
+  readonly hs1_8xlarge: "hs1.8xlarge";
+  readonly i2_2xlarge: "i2.2xlarge";
+  readonly i2_4xlarge: "i2.4xlarge";
+  readonly i2_8xlarge: "i2.8xlarge";
+  readonly i2_xlarge: "i2.xlarge";
+  readonly i3_16xlarge: "i3.16xlarge";
+  readonly i3_2xlarge: "i3.2xlarge";
+  readonly i3_4xlarge: "i3.4xlarge";
+  readonly i3_8xlarge: "i3.8xlarge";
+  readonly i3_large: "i3.large";
+  readonly i3_metal: "i3.metal";
+  readonly i3_xlarge: "i3.xlarge";
+  readonly i3en_12xlarge: "i3en.12xlarge";
+  readonly i3en_24xlarge: "i3en.24xlarge";
+  readonly i3en_2xlarge: "i3en.2xlarge";
+  readonly i3en_3xlarge: "i3en.3xlarge";
+  readonly i3en_6xlarge: "i3en.6xlarge";
+  readonly i3en_large: "i3en.large";
+  readonly i3en_metal: "i3en.metal";
+  readonly i3en_xlarge: "i3en.xlarge";
+  readonly i4g_16xlarge: "i4g.16xlarge";
+  readonly i4g_2xlarge: "i4g.2xlarge";
+  readonly i4g_4xlarge: "i4g.4xlarge";
+  readonly i4g_8xlarge: "i4g.8xlarge";
+  readonly i4g_large: "i4g.large";
+  readonly i4g_xlarge: "i4g.xlarge";
+  readonly i4i_12xlarge: "i4i.12xlarge";
+  readonly i4i_16xlarge: "i4i.16xlarge";
+  readonly i4i_24xlarge: "i4i.24xlarge";
+  readonly i4i_2xlarge: "i4i.2xlarge";
+  readonly i4i_32xlarge: "i4i.32xlarge";
+  readonly i4i_4xlarge: "i4i.4xlarge";
+  readonly i4i_8xlarge: "i4i.8xlarge";
+  readonly i4i_large: "i4i.large";
+  readonly i4i_metal: "i4i.metal";
+  readonly i4i_xlarge: "i4i.xlarge";
+  readonly i7i_12xlarge: "i7i.12xlarge";
+  readonly i7i_16xlarge: "i7i.16xlarge";
+  readonly i7i_24xlarge: "i7i.24xlarge";
+  readonly i7i_2xlarge: "i7i.2xlarge";
+  readonly i7i_48xlarge: "i7i.48xlarge";
+  readonly i7i_4xlarge: "i7i.4xlarge";
+  readonly i7i_8xlarge: "i7i.8xlarge";
+  readonly i7i_large: "i7i.large";
+  readonly i7i_metal_24xl: "i7i.metal-24xl";
+  readonly i7i_metal_48xl: "i7i.metal-48xl";
+  readonly i7i_xlarge: "i7i.xlarge";
+  readonly i7ie_12xlarge: "i7ie.12xlarge";
+  readonly i7ie_18xlarge: "i7ie.18xlarge";
+  readonly i7ie_24xlarge: "i7ie.24xlarge";
+  readonly i7ie_2xlarge: "i7ie.2xlarge";
+  readonly i7ie_3xlarge: "i7ie.3xlarge";
+  readonly i7ie_48xlarge: "i7ie.48xlarge";
+  readonly i7ie_6xlarge: "i7ie.6xlarge";
+  readonly i7ie_large: "i7ie.large";
+  readonly i7ie_metal_24xl: "i7ie.metal-24xl";
+  readonly i7ie_metal_48xl: "i7ie.metal-48xl";
+  readonly i7ie_xlarge: "i7ie.xlarge";
+  readonly i8g_12xlarge: "i8g.12xlarge";
+  readonly i8g_16xlarge: "i8g.16xlarge";
+  readonly i8g_24xlarge: "i8g.24xlarge";
+  readonly i8g_2xlarge: "i8g.2xlarge";
+  readonly i8g_48xlarge: "i8g.48xlarge";
+  readonly i8g_4xlarge: "i8g.4xlarge";
+  readonly i8g_8xlarge: "i8g.8xlarge";
+  readonly i8g_large: "i8g.large";
+  readonly i8g_metal_24xl: "i8g.metal-24xl";
+  readonly i8g_xlarge: "i8g.xlarge";
+  readonly i8ge_12xlarge: "i8ge.12xlarge";
+  readonly i8ge_18xlarge: "i8ge.18xlarge";
+  readonly i8ge_24xlarge: "i8ge.24xlarge";
+  readonly i8ge_2xlarge: "i8ge.2xlarge";
+  readonly i8ge_3xlarge: "i8ge.3xlarge";
+  readonly i8ge_48xlarge: "i8ge.48xlarge";
+  readonly i8ge_6xlarge: "i8ge.6xlarge";
+  readonly i8ge_large: "i8ge.large";
+  readonly i8ge_metal_24xl: "i8ge.metal-24xl";
+  readonly i8ge_metal_48xl: "i8ge.metal-48xl";
+  readonly i8ge_xlarge: "i8ge.xlarge";
+  readonly im4gn_16xlarge: "im4gn.16xlarge";
+  readonly im4gn_2xlarge: "im4gn.2xlarge";
+  readonly im4gn_4xlarge: "im4gn.4xlarge";
+  readonly im4gn_8xlarge: "im4gn.8xlarge";
+  readonly im4gn_large: "im4gn.large";
+  readonly im4gn_xlarge: "im4gn.xlarge";
+  readonly inf1_24xlarge: "inf1.24xlarge";
+  readonly inf1_2xlarge: "inf1.2xlarge";
+  readonly inf1_6xlarge: "inf1.6xlarge";
+  readonly inf1_xlarge: "inf1.xlarge";
+  readonly inf2_24xlarge: "inf2.24xlarge";
+  readonly inf2_48xlarge: "inf2.48xlarge";
+  readonly inf2_8xlarge: "inf2.8xlarge";
+  readonly inf2_xlarge: "inf2.xlarge";
+  readonly is4gen_2xlarge: "is4gen.2xlarge";
+  readonly is4gen_4xlarge: "is4gen.4xlarge";
+  readonly is4gen_8xlarge: "is4gen.8xlarge";
+  readonly is4gen_large: "is4gen.large";
+  readonly is4gen_medium: "is4gen.medium";
+  readonly is4gen_xlarge: "is4gen.xlarge";
+  readonly m1_large: "m1.large";
+  readonly m1_medium: "m1.medium";
+  readonly m1_small: "m1.small";
+  readonly m1_xlarge: "m1.xlarge";
+  readonly m2_2xlarge: "m2.2xlarge";
+  readonly m2_4xlarge: "m2.4xlarge";
+  readonly m2_xlarge: "m2.xlarge";
+  readonly m3_2xlarge: "m3.2xlarge";
+  readonly m3_large: "m3.large";
+  readonly m3_medium: "m3.medium";
+  readonly m3_xlarge: "m3.xlarge";
+  readonly m4_10xlarge: "m4.10xlarge";
+  readonly m4_16xlarge: "m4.16xlarge";
+  readonly m4_2xlarge: "m4.2xlarge";
+  readonly m4_4xlarge: "m4.4xlarge";
+  readonly m4_large: "m4.large";
+  readonly m4_xlarge: "m4.xlarge";
+  readonly m5_12xlarge: "m5.12xlarge";
+  readonly m5_16xlarge: "m5.16xlarge";
+  readonly m5_24xlarge: "m5.24xlarge";
+  readonly m5_2xlarge: "m5.2xlarge";
+  readonly m5_4xlarge: "m5.4xlarge";
+  readonly m5_8xlarge: "m5.8xlarge";
+  readonly m5_large: "m5.large";
+  readonly m5_metal: "m5.metal";
+  readonly m5_xlarge: "m5.xlarge";
+  readonly m5a_12xlarge: "m5a.12xlarge";
+  readonly m5a_16xlarge: "m5a.16xlarge";
+  readonly m5a_24xlarge: "m5a.24xlarge";
+  readonly m5a_2xlarge: "m5a.2xlarge";
+  readonly m5a_4xlarge: "m5a.4xlarge";
+  readonly m5a_8xlarge: "m5a.8xlarge";
+  readonly m5a_large: "m5a.large";
+  readonly m5a_xlarge: "m5a.xlarge";
+  readonly m5ad_12xlarge: "m5ad.12xlarge";
+  readonly m5ad_16xlarge: "m5ad.16xlarge";
+  readonly m5ad_24xlarge: "m5ad.24xlarge";
+  readonly m5ad_2xlarge: "m5ad.2xlarge";
+  readonly m5ad_4xlarge: "m5ad.4xlarge";
+  readonly m5ad_8xlarge: "m5ad.8xlarge";
+  readonly m5ad_large: "m5ad.large";
+  readonly m5ad_xlarge: "m5ad.xlarge";
+  readonly m5d_12xlarge: "m5d.12xlarge";
+  readonly m5d_16xlarge: "m5d.16xlarge";
+  readonly m5d_24xlarge: "m5d.24xlarge";
+  readonly m5d_2xlarge: "m5d.2xlarge";
+  readonly m5d_4xlarge: "m5d.4xlarge";
+  readonly m5d_8xlarge: "m5d.8xlarge";
+  readonly m5d_large: "m5d.large";
+  readonly m5d_metal: "m5d.metal";
+  readonly m5d_xlarge: "m5d.xlarge";
+  readonly m5dn_12xlarge: "m5dn.12xlarge";
+  readonly m5dn_16xlarge: "m5dn.16xlarge";
+  readonly m5dn_24xlarge: "m5dn.24xlarge";
+  readonly m5dn_2xlarge: "m5dn.2xlarge";
+  readonly m5dn_4xlarge: "m5dn.4xlarge";
+  readonly m5dn_8xlarge: "m5dn.8xlarge";
+  readonly m5dn_large: "m5dn.large";
+  readonly m5dn_metal: "m5dn.metal";
+  readonly m5dn_xlarge: "m5dn.xlarge";
+  readonly m5n_12xlarge: "m5n.12xlarge";
+  readonly m5n_16xlarge: "m5n.16xlarge";
+  readonly m5n_24xlarge: "m5n.24xlarge";
+  readonly m5n_2xlarge: "m5n.2xlarge";
+  readonly m5n_4xlarge: "m5n.4xlarge";
+  readonly m5n_8xlarge: "m5n.8xlarge";
+  readonly m5n_large: "m5n.large";
+  readonly m5n_metal: "m5n.metal";
+  readonly m5n_xlarge: "m5n.xlarge";
+  readonly m5zn_12xlarge: "m5zn.12xlarge";
+  readonly m5zn_2xlarge: "m5zn.2xlarge";
+  readonly m5zn_3xlarge: "m5zn.3xlarge";
+  readonly m5zn_6xlarge: "m5zn.6xlarge";
+  readonly m5zn_large: "m5zn.large";
+  readonly m5zn_metal: "m5zn.metal";
+  readonly m5zn_xlarge: "m5zn.xlarge";
+  readonly m6a_12xlarge: "m6a.12xlarge";
+  readonly m6a_16xlarge: "m6a.16xlarge";
+  readonly m6a_24xlarge: "m6a.24xlarge";
+  readonly m6a_2xlarge: "m6a.2xlarge";
+  readonly m6a_32xlarge: "m6a.32xlarge";
+  readonly m6a_48xlarge: "m6a.48xlarge";
+  readonly m6a_4xlarge: "m6a.4xlarge";
+  readonly m6a_8xlarge: "m6a.8xlarge";
+  readonly m6a_large: "m6a.large";
+  readonly m6a_metal: "m6a.metal";
+  readonly m6a_xlarge: "m6a.xlarge";
+  readonly m6g_12xlarge: "m6g.12xlarge";
+  readonly m6g_16xlarge: "m6g.16xlarge";
+  readonly m6g_2xlarge: "m6g.2xlarge";
+  readonly m6g_4xlarge: "m6g.4xlarge";
+  readonly m6g_8xlarge: "m6g.8xlarge";
+  readonly m6g_large: "m6g.large";
+  readonly m6g_medium: "m6g.medium";
+  readonly m6g_metal: "m6g.metal";
+  readonly m6g_xlarge: "m6g.xlarge";
+  readonly m6gd_12xlarge: "m6gd.12xlarge";
+  readonly m6gd_16xlarge: "m6gd.16xlarge";
+  readonly m6gd_2xlarge: "m6gd.2xlarge";
+  readonly m6gd_4xlarge: "m6gd.4xlarge";
+  readonly m6gd_8xlarge: "m6gd.8xlarge";
+  readonly m6gd_large: "m6gd.large";
+  readonly m6gd_medium: "m6gd.medium";
+  readonly m6gd_metal: "m6gd.metal";
+  readonly m6gd_xlarge: "m6gd.xlarge";
+  readonly m6i_12xlarge: "m6i.12xlarge";
+  readonly m6i_16xlarge: "m6i.16xlarge";
+  readonly m6i_24xlarge: "m6i.24xlarge";
+  readonly m6i_2xlarge: "m6i.2xlarge";
+  readonly m6i_32xlarge: "m6i.32xlarge";
+  readonly m6i_4xlarge: "m6i.4xlarge";
+  readonly m6i_8xlarge: "m6i.8xlarge";
+  readonly m6i_large: "m6i.large";
+  readonly m6i_metal: "m6i.metal";
+  readonly m6i_xlarge: "m6i.xlarge";
+  readonly m6id_12xlarge: "m6id.12xlarge";
+  readonly m6id_16xlarge: "m6id.16xlarge";
+  readonly m6id_24xlarge: "m6id.24xlarge";
+  readonly m6id_2xlarge: "m6id.2xlarge";
+  readonly m6id_32xlarge: "m6id.32xlarge";
+  readonly m6id_4xlarge: "m6id.4xlarge";
+  readonly m6id_8xlarge: "m6id.8xlarge";
+  readonly m6id_large: "m6id.large";
+  readonly m6id_metal: "m6id.metal";
+  readonly m6id_xlarge: "m6id.xlarge";
+  readonly m6idn_12xlarge: "m6idn.12xlarge";
+  readonly m6idn_16xlarge: "m6idn.16xlarge";
+  readonly m6idn_24xlarge: "m6idn.24xlarge";
+  readonly m6idn_2xlarge: "m6idn.2xlarge";
+  readonly m6idn_32xlarge: "m6idn.32xlarge";
+  readonly m6idn_4xlarge: "m6idn.4xlarge";
+  readonly m6idn_8xlarge: "m6idn.8xlarge";
+  readonly m6idn_large: "m6idn.large";
+  readonly m6idn_metal: "m6idn.metal";
+  readonly m6idn_xlarge: "m6idn.xlarge";
+  readonly m6in_12xlarge: "m6in.12xlarge";
+  readonly m6in_16xlarge: "m6in.16xlarge";
+  readonly m6in_24xlarge: "m6in.24xlarge";
+  readonly m6in_2xlarge: "m6in.2xlarge";
+  readonly m6in_32xlarge: "m6in.32xlarge";
+  readonly m6in_4xlarge: "m6in.4xlarge";
+  readonly m6in_8xlarge: "m6in.8xlarge";
+  readonly m6in_large: "m6in.large";
+  readonly m6in_metal: "m6in.metal";
+  readonly m6in_xlarge: "m6in.xlarge";
+  readonly m7a_12xlarge: "m7a.12xlarge";
+  readonly m7a_16xlarge: "m7a.16xlarge";
+  readonly m7a_24xlarge: "m7a.24xlarge";
+  readonly m7a_2xlarge: "m7a.2xlarge";
+  readonly m7a_32xlarge: "m7a.32xlarge";
+  readonly m7a_48xlarge: "m7a.48xlarge";
+  readonly m7a_4xlarge: "m7a.4xlarge";
+  readonly m7a_8xlarge: "m7a.8xlarge";
+  readonly m7a_large: "m7a.large";
+  readonly m7a_medium: "m7a.medium";
+  readonly m7a_metal_48xl: "m7a.metal-48xl";
+  readonly m7a_xlarge: "m7a.xlarge";
+  readonly m7g_12xlarge: "m7g.12xlarge";
+  readonly m7g_16xlarge: "m7g.16xlarge";
+  readonly m7g_2xlarge: "m7g.2xlarge";
+  readonly m7g_4xlarge: "m7g.4xlarge";
+  readonly m7g_8xlarge: "m7g.8xlarge";
+  readonly m7g_large: "m7g.large";
+  readonly m7g_medium: "m7g.medium";
+  readonly m7g_metal: "m7g.metal";
+  readonly m7g_xlarge: "m7g.xlarge";
+  readonly m7gd_12xlarge: "m7gd.12xlarge";
+  readonly m7gd_16xlarge: "m7gd.16xlarge";
+  readonly m7gd_2xlarge: "m7gd.2xlarge";
+  readonly m7gd_4xlarge: "m7gd.4xlarge";
+  readonly m7gd_8xlarge: "m7gd.8xlarge";
+  readonly m7gd_large: "m7gd.large";
+  readonly m7gd_medium: "m7gd.medium";
+  readonly m7gd_metal: "m7gd.metal";
+  readonly m7gd_xlarge: "m7gd.xlarge";
+  readonly m7i_12xlarge: "m7i.12xlarge";
+  readonly m7i_16xlarge: "m7i.16xlarge";
+  readonly m7i_24xlarge: "m7i.24xlarge";
+  readonly m7i_2xlarge: "m7i.2xlarge";
+  readonly m7i_48xlarge: "m7i.48xlarge";
+  readonly m7i_4xlarge: "m7i.4xlarge";
+  readonly m7i_8xlarge: "m7i.8xlarge";
+  readonly m7i_flex_12xlarge: "m7i-flex.12xlarge";
+  readonly m7i_flex_16xlarge: "m7i-flex.16xlarge";
+  readonly m7i_flex_2xlarge: "m7i-flex.2xlarge";
+  readonly m7i_flex_4xlarge: "m7i-flex.4xlarge";
+  readonly m7i_flex_8xlarge: "m7i-flex.8xlarge";
+  readonly m7i_flex_large: "m7i-flex.large";
+  readonly m7i_flex_xlarge: "m7i-flex.xlarge";
+  readonly m7i_large: "m7i.large";
+  readonly m7i_metal_24xl: "m7i.metal-24xl";
+  readonly m7i_metal_48xl: "m7i.metal-48xl";
+  readonly m7i_xlarge: "m7i.xlarge";
+  readonly m8a_12xlarge: "m8a.12xlarge";
+  readonly m8a_16xlarge: "m8a.16xlarge";
+  readonly m8a_24xlarge: "m8a.24xlarge";
+  readonly m8a_2xlarge: "m8a.2xlarge";
+  readonly m8a_48xlarge: "m8a.48xlarge";
+  readonly m8a_4xlarge: "m8a.4xlarge";
+  readonly m8a_8xlarge: "m8a.8xlarge";
+  readonly m8a_large: "m8a.large";
+  readonly m8a_medium: "m8a.medium";
+  readonly m8a_metal_24xl: "m8a.metal-24xl";
+  readonly m8a_metal_48xl: "m8a.metal-48xl";
+  readonly m8a_xlarge: "m8a.xlarge";
+  readonly m8g_12xlarge: "m8g.12xlarge";
+  readonly m8g_16xlarge: "m8g.16xlarge";
+  readonly m8g_24xlarge: "m8g.24xlarge";
+  readonly m8g_2xlarge: "m8g.2xlarge";
+  readonly m8g_48xlarge: "m8g.48xlarge";
+  readonly m8g_4xlarge: "m8g.4xlarge";
+  readonly m8g_8xlarge: "m8g.8xlarge";
+  readonly m8g_large: "m8g.large";
+  readonly m8g_medium: "m8g.medium";
+  readonly m8g_metal_24xl: "m8g.metal-24xl";
+  readonly m8g_metal_48xl: "m8g.metal-48xl";
+  readonly m8g_xlarge: "m8g.xlarge";
+  readonly m8gd_12xlarge: "m8gd.12xlarge";
+  readonly m8gd_16xlarge: "m8gd.16xlarge";
+  readonly m8gd_24xlarge: "m8gd.24xlarge";
+  readonly m8gd_2xlarge: "m8gd.2xlarge";
+  readonly m8gd_48xlarge: "m8gd.48xlarge";
+  readonly m8gd_4xlarge: "m8gd.4xlarge";
+  readonly m8gd_8xlarge: "m8gd.8xlarge";
+  readonly m8gd_large: "m8gd.large";
+  readonly m8gd_medium: "m8gd.medium";
+  readonly m8gd_metal_24xl: "m8gd.metal-24xl";
+  readonly m8gd_metal_48xl: "m8gd.metal-48xl";
+  readonly m8gd_xlarge: "m8gd.xlarge";
+  readonly m8i_12xlarge: "m8i.12xlarge";
+  readonly m8i_16xlarge: "m8i.16xlarge";
+  readonly m8i_24xlarge: "m8i.24xlarge";
+  readonly m8i_2xlarge: "m8i.2xlarge";
+  readonly m8i_32xlarge: "m8i.32xlarge";
+  readonly m8i_48xlarge: "m8i.48xlarge";
+  readonly m8i_4xlarge: "m8i.4xlarge";
+  readonly m8i_8xlarge: "m8i.8xlarge";
+  readonly m8i_96xlarge: "m8i.96xlarge";
+  readonly m8i_flex_12xlarge: "m8i-flex.12xlarge";
+  readonly m8i_flex_16xlarge: "m8i-flex.16xlarge";
+  readonly m8i_flex_2xlarge: "m8i-flex.2xlarge";
+  readonly m8i_flex_4xlarge: "m8i-flex.4xlarge";
+  readonly m8i_flex_8xlarge: "m8i-flex.8xlarge";
+  readonly m8i_flex_large: "m8i-flex.large";
+  readonly m8i_flex_xlarge: "m8i-flex.xlarge";
+  readonly m8i_large: "m8i.large";
+  readonly m8i_metal_48xl: "m8i.metal-48xl";
+  readonly m8i_metal_96xl: "m8i.metal-96xl";
+  readonly m8i_xlarge: "m8i.xlarge";
+  readonly mac1_metal: "mac1.metal";
+  readonly mac2_m1ultra_metal: "mac2-m1ultra.metal";
+  readonly mac2_m2_metal: "mac2-m2.metal";
+  readonly mac2_m2pro_metal: "mac2-m2pro.metal";
+  readonly mac2_metal: "mac2.metal";
+  readonly mac_m4_metal: "mac-m4.metal";
+  readonly mac_m4pro_metal: "mac-m4pro.metal";
+  readonly p2_16xlarge: "p2.16xlarge";
+  readonly p2_8xlarge: "p2.8xlarge";
+  readonly p2_xlarge: "p2.xlarge";
+  readonly p3_16xlarge: "p3.16xlarge";
+  readonly p3_2xlarge: "p3.2xlarge";
+  readonly p3_8xlarge: "p3.8xlarge";
+  readonly p3dn_24xlarge: "p3dn.24xlarge";
+  readonly p4d_24xlarge: "p4d.24xlarge";
+  readonly p4de_24xlarge: "p4de.24xlarge";
+  readonly p5_48xlarge: "p5.48xlarge";
+  readonly p5_4xlarge: "p5.4xlarge";
+  readonly p5e_48xlarge: "p5e.48xlarge";
+  readonly p5en_48xlarge: "p5en.48xlarge";
+  readonly p6_b200_48xlarge: "p6-b200.48xlarge";
+  readonly p6e_gb200_36xlarge: "p6e-gb200.36xlarge";
+  readonly r3_2xlarge: "r3.2xlarge";
+  readonly r3_4xlarge: "r3.4xlarge";
+  readonly r3_8xlarge: "r3.8xlarge";
+  readonly r3_large: "r3.large";
+  readonly r3_xlarge: "r3.xlarge";
+  readonly r4_16xlarge: "r4.16xlarge";
+  readonly r4_2xlarge: "r4.2xlarge";
+  readonly r4_4xlarge: "r4.4xlarge";
+  readonly r4_8xlarge: "r4.8xlarge";
+  readonly r4_large: "r4.large";
+  readonly r4_xlarge: "r4.xlarge";
+  readonly r5_12xlarge: "r5.12xlarge";
+  readonly r5_16xlarge: "r5.16xlarge";
+  readonly r5_24xlarge: "r5.24xlarge";
+  readonly r5_2xlarge: "r5.2xlarge";
+  readonly r5_4xlarge: "r5.4xlarge";
+  readonly r5_8xlarge: "r5.8xlarge";
+  readonly r5_large: "r5.large";
+  readonly r5_metal: "r5.metal";
+  readonly r5_xlarge: "r5.xlarge";
+  readonly r5a_12xlarge: "r5a.12xlarge";
+  readonly r5a_16xlarge: "r5a.16xlarge";
+  readonly r5a_24xlarge: "r5a.24xlarge";
+  readonly r5a_2xlarge: "r5a.2xlarge";
+  readonly r5a_4xlarge: "r5a.4xlarge";
+  readonly r5a_8xlarge: "r5a.8xlarge";
+  readonly r5a_large: "r5a.large";
+  readonly r5a_xlarge: "r5a.xlarge";
+  readonly r5ad_12xlarge: "r5ad.12xlarge";
+  readonly r5ad_16xlarge: "r5ad.16xlarge";
+  readonly r5ad_24xlarge: "r5ad.24xlarge";
+  readonly r5ad_2xlarge: "r5ad.2xlarge";
+  readonly r5ad_4xlarge: "r5ad.4xlarge";
+  readonly r5ad_8xlarge: "r5ad.8xlarge";
+  readonly r5ad_large: "r5ad.large";
+  readonly r5ad_xlarge: "r5ad.xlarge";
+  readonly r5b_12xlarge: "r5b.12xlarge";
+  readonly r5b_16xlarge: "r5b.16xlarge";
+  readonly r5b_24xlarge: "r5b.24xlarge";
+  readonly r5b_2xlarge: "r5b.2xlarge";
+  readonly r5b_4xlarge: "r5b.4xlarge";
+  readonly r5b_8xlarge: "r5b.8xlarge";
+  readonly r5b_large: "r5b.large";
+  readonly r5b_metal: "r5b.metal";
+  readonly r5b_xlarge: "r5b.xlarge";
+  readonly r5d_12xlarge: "r5d.12xlarge";
+  readonly r5d_16xlarge: "r5d.16xlarge";
+  readonly r5d_24xlarge: "r5d.24xlarge";
+  readonly r5d_2xlarge: "r5d.2xlarge";
+  readonly r5d_4xlarge: "r5d.4xlarge";
+  readonly r5d_8xlarge: "r5d.8xlarge";
+  readonly r5d_large: "r5d.large";
+  readonly r5d_metal: "r5d.metal";
+  readonly r5d_xlarge: "r5d.xlarge";
+  readonly r5dn_12xlarge: "r5dn.12xlarge";
+  readonly r5dn_16xlarge: "r5dn.16xlarge";
+  readonly r5dn_24xlarge: "r5dn.24xlarge";
+  readonly r5dn_2xlarge: "r5dn.2xlarge";
+  readonly r5dn_4xlarge: "r5dn.4xlarge";
+  readonly r5dn_8xlarge: "r5dn.8xlarge";
+  readonly r5dn_large: "r5dn.large";
+  readonly r5dn_metal: "r5dn.metal";
+  readonly r5dn_xlarge: "r5dn.xlarge";
+  readonly r5n_12xlarge: "r5n.12xlarge";
+  readonly r5n_16xlarge: "r5n.16xlarge";
+  readonly r5n_24xlarge: "r5n.24xlarge";
+  readonly r5n_2xlarge: "r5n.2xlarge";
+  readonly r5n_4xlarge: "r5n.4xlarge";
+  readonly r5n_8xlarge: "r5n.8xlarge";
+  readonly r5n_large: "r5n.large";
+  readonly r5n_metal: "r5n.metal";
+  readonly r5n_xlarge: "r5n.xlarge";
+  readonly r6a_12xlarge: "r6a.12xlarge";
+  readonly r6a_16xlarge: "r6a.16xlarge";
+  readonly r6a_24xlarge: "r6a.24xlarge";
+  readonly r6a_2xlarge: "r6a.2xlarge";
+  readonly r6a_32xlarge: "r6a.32xlarge";
+  readonly r6a_48xlarge: "r6a.48xlarge";
+  readonly r6a_4xlarge: "r6a.4xlarge";
+  readonly r6a_8xlarge: "r6a.8xlarge";
+  readonly r6a_large: "r6a.large";
+  readonly r6a_metal: "r6a.metal";
+  readonly r6a_xlarge: "r6a.xlarge";
+  readonly r6g_12xlarge: "r6g.12xlarge";
+  readonly r6g_16xlarge: "r6g.16xlarge";
+  readonly r6g_2xlarge: "r6g.2xlarge";
+  readonly r6g_4xlarge: "r6g.4xlarge";
+  readonly r6g_8xlarge: "r6g.8xlarge";
+  readonly r6g_large: "r6g.large";
+  readonly r6g_medium: "r6g.medium";
+  readonly r6g_metal: "r6g.metal";
+  readonly r6g_xlarge: "r6g.xlarge";
+  readonly r6gd_12xlarge: "r6gd.12xlarge";
+  readonly r6gd_16xlarge: "r6gd.16xlarge";
+  readonly r6gd_2xlarge: "r6gd.2xlarge";
+  readonly r6gd_4xlarge: "r6gd.4xlarge";
+  readonly r6gd_8xlarge: "r6gd.8xlarge";
+  readonly r6gd_large: "r6gd.large";
+  readonly r6gd_medium: "r6gd.medium";
+  readonly r6gd_metal: "r6gd.metal";
+  readonly r6gd_xlarge: "r6gd.xlarge";
+  readonly r6i_12xlarge: "r6i.12xlarge";
+  readonly r6i_16xlarge: "r6i.16xlarge";
+  readonly r6i_24xlarge: "r6i.24xlarge";
+  readonly r6i_2xlarge: "r6i.2xlarge";
+  readonly r6i_32xlarge: "r6i.32xlarge";
+  readonly r6i_4xlarge: "r6i.4xlarge";
+  readonly r6i_8xlarge: "r6i.8xlarge";
+  readonly r6i_large: "r6i.large";
+  readonly r6i_metal: "r6i.metal";
+  readonly r6i_xlarge: "r6i.xlarge";
+  readonly r6id_12xlarge: "r6id.12xlarge";
+  readonly r6id_16xlarge: "r6id.16xlarge";
+  readonly r6id_24xlarge: "r6id.24xlarge";
+  readonly r6id_2xlarge: "r6id.2xlarge";
+  readonly r6id_32xlarge: "r6id.32xlarge";
+  readonly r6id_4xlarge: "r6id.4xlarge";
+  readonly r6id_8xlarge: "r6id.8xlarge";
+  readonly r6id_large: "r6id.large";
+  readonly r6id_metal: "r6id.metal";
+  readonly r6id_xlarge: "r6id.xlarge";
+  readonly r6idn_12xlarge: "r6idn.12xlarge";
+  readonly r6idn_16xlarge: "r6idn.16xlarge";
+  readonly r6idn_24xlarge: "r6idn.24xlarge";
+  readonly r6idn_2xlarge: "r6idn.2xlarge";
+  readonly r6idn_32xlarge: "r6idn.32xlarge";
+  readonly r6idn_4xlarge: "r6idn.4xlarge";
+  readonly r6idn_8xlarge: "r6idn.8xlarge";
+  readonly r6idn_large: "r6idn.large";
+  readonly r6idn_metal: "r6idn.metal";
+  readonly r6idn_xlarge: "r6idn.xlarge";
+  readonly r6in_12xlarge: "r6in.12xlarge";
+  readonly r6in_16xlarge: "r6in.16xlarge";
+  readonly r6in_24xlarge: "r6in.24xlarge";
+  readonly r6in_2xlarge: "r6in.2xlarge";
+  readonly r6in_32xlarge: "r6in.32xlarge";
+  readonly r6in_4xlarge: "r6in.4xlarge";
+  readonly r6in_8xlarge: "r6in.8xlarge";
+  readonly r6in_large: "r6in.large";
+  readonly r6in_metal: "r6in.metal";
+  readonly r6in_xlarge: "r6in.xlarge";
+  readonly r7a_12xlarge: "r7a.12xlarge";
+  readonly r7a_16xlarge: "r7a.16xlarge";
+  readonly r7a_24xlarge: "r7a.24xlarge";
+  readonly r7a_2xlarge: "r7a.2xlarge";
+  readonly r7a_32xlarge: "r7a.32xlarge";
+  readonly r7a_48xlarge: "r7a.48xlarge";
+  readonly r7a_4xlarge: "r7a.4xlarge";
+  readonly r7a_8xlarge: "r7a.8xlarge";
+  readonly r7a_large: "r7a.large";
+  readonly r7a_medium: "r7a.medium";
+  readonly r7a_metal_48xl: "r7a.metal-48xl";
+  readonly r7a_xlarge: "r7a.xlarge";
+  readonly r7g_12xlarge: "r7g.12xlarge";
+  readonly r7g_16xlarge: "r7g.16xlarge";
+  readonly r7g_2xlarge: "r7g.2xlarge";
+  readonly r7g_4xlarge: "r7g.4xlarge";
+  readonly r7g_8xlarge: "r7g.8xlarge";
+  readonly r7g_large: "r7g.large";
+  readonly r7g_medium: "r7g.medium";
+  readonly r7g_metal: "r7g.metal";
+  readonly r7g_xlarge: "r7g.xlarge";
+  readonly r7gd_12xlarge: "r7gd.12xlarge";
+  readonly r7gd_16xlarge: "r7gd.16xlarge";
+  readonly r7gd_2xlarge: "r7gd.2xlarge";
+  readonly r7gd_4xlarge: "r7gd.4xlarge";
+  readonly r7gd_8xlarge: "r7gd.8xlarge";
+  readonly r7gd_large: "r7gd.large";
+  readonly r7gd_medium: "r7gd.medium";
+  readonly r7gd_metal: "r7gd.metal";
+  readonly r7gd_xlarge: "r7gd.xlarge";
+  readonly r7i_12xlarge: "r7i.12xlarge";
+  readonly r7i_16xlarge: "r7i.16xlarge";
+  readonly r7i_24xlarge: "r7i.24xlarge";
+  readonly r7i_2xlarge: "r7i.2xlarge";
+  readonly r7i_48xlarge: "r7i.48xlarge";
+  readonly r7i_4xlarge: "r7i.4xlarge";
+  readonly r7i_8xlarge: "r7i.8xlarge";
+  readonly r7i_large: "r7i.large";
+  readonly r7i_metal_24xl: "r7i.metal-24xl";
+  readonly r7i_metal_48xl: "r7i.metal-48xl";
+  readonly r7i_xlarge: "r7i.xlarge";
+  readonly r7iz_12xlarge: "r7iz.12xlarge";
+  readonly r7iz_16xlarge: "r7iz.16xlarge";
+  readonly r7iz_2xlarge: "r7iz.2xlarge";
+  readonly r7iz_32xlarge: "r7iz.32xlarge";
+  readonly r7iz_4xlarge: "r7iz.4xlarge";
+  readonly r7iz_8xlarge: "r7iz.8xlarge";
+  readonly r7iz_large: "r7iz.large";
+  readonly r7iz_metal_16xl: "r7iz.metal-16xl";
+  readonly r7iz_metal_32xl: "r7iz.metal-32xl";
+  readonly r7iz_xlarge: "r7iz.xlarge";
+  readonly r8a_12xlarge: "r8a.12xlarge";
+  readonly r8a_16xlarge: "r8a.16xlarge";
+  readonly r8a_24xlarge: "r8a.24xlarge";
+  readonly r8a_2xlarge: "r8a.2xlarge";
+  readonly r8a_48xlarge: "r8a.48xlarge";
+  readonly r8a_4xlarge: "r8a.4xlarge";
+  readonly r8a_8xlarge: "r8a.8xlarge";
+  readonly r8a_large: "r8a.large";
+  readonly r8a_medium: "r8a.medium";
+  readonly r8a_metal_24xl: "r8a.metal-24xl";
+  readonly r8a_metal_48xl: "r8a.metal-48xl";
+  readonly r8a_xlarge: "r8a.xlarge";
+  readonly r8g_12xlarge: "r8g.12xlarge";
+  readonly r8g_16xlarge: "r8g.16xlarge";
+  readonly r8g_24xlarge: "r8g.24xlarge";
+  readonly r8g_2xlarge: "r8g.2xlarge";
+  readonly r8g_48xlarge: "r8g.48xlarge";
+  readonly r8g_4xlarge: "r8g.4xlarge";
+  readonly r8g_8xlarge: "r8g.8xlarge";
+  readonly r8g_large: "r8g.large";
+  readonly r8g_medium: "r8g.medium";
+  readonly r8g_metal_24xl: "r8g.metal-24xl";
+  readonly r8g_metal_48xl: "r8g.metal-48xl";
+  readonly r8g_xlarge: "r8g.xlarge";
+  readonly r8gb_12xlarge: "r8gb.12xlarge";
+  readonly r8gb_16xlarge: "r8gb.16xlarge";
+  readonly r8gb_24xlarge: "r8gb.24xlarge";
+  readonly r8gb_2xlarge: "r8gb.2xlarge";
+  readonly r8gb_4xlarge: "r8gb.4xlarge";
+  readonly r8gb_8xlarge: "r8gb.8xlarge";
+  readonly r8gb_large: "r8gb.large";
+  readonly r8gb_medium: "r8gb.medium";
+  readonly r8gb_metal_24xl: "r8gb.metal-24xl";
+  readonly r8gb_xlarge: "r8gb.xlarge";
+  readonly r8gd_12xlarge: "r8gd.12xlarge";
+  readonly r8gd_16xlarge: "r8gd.16xlarge";
+  readonly r8gd_24xlarge: "r8gd.24xlarge";
+  readonly r8gd_2xlarge: "r8gd.2xlarge";
+  readonly r8gd_48xlarge: "r8gd.48xlarge";
+  readonly r8gd_4xlarge: "r8gd.4xlarge";
+  readonly r8gd_8xlarge: "r8gd.8xlarge";
+  readonly r8gd_large: "r8gd.large";
+  readonly r8gd_medium: "r8gd.medium";
+  readonly r8gd_metal_24xl: "r8gd.metal-24xl";
+  readonly r8gd_metal_48xl: "r8gd.metal-48xl";
+  readonly r8gd_xlarge: "r8gd.xlarge";
+  readonly r8gn_12xlarge: "r8gn.12xlarge";
+  readonly r8gn_16xlarge: "r8gn.16xlarge";
+  readonly r8gn_24xlarge: "r8gn.24xlarge";
+  readonly r8gn_2xlarge: "r8gn.2xlarge";
+  readonly r8gn_48xlarge: "r8gn.48xlarge";
+  readonly r8gn_4xlarge: "r8gn.4xlarge";
+  readonly r8gn_8xlarge: "r8gn.8xlarge";
+  readonly r8gn_large: "r8gn.large";
+  readonly r8gn_medium: "r8gn.medium";
+  readonly r8gn_metal_24xl: "r8gn.metal-24xl";
+  readonly r8gn_metal_48xl: "r8gn.metal-48xl";
+  readonly r8gn_xlarge: "r8gn.xlarge";
+  readonly r8i_12xlarge: "r8i.12xlarge";
+  readonly r8i_16xlarge: "r8i.16xlarge";
+  readonly r8i_24xlarge: "r8i.24xlarge";
+  readonly r8i_2xlarge: "r8i.2xlarge";
+  readonly r8i_32xlarge: "r8i.32xlarge";
+  readonly r8i_48xlarge: "r8i.48xlarge";
+  readonly r8i_4xlarge: "r8i.4xlarge";
+  readonly r8i_8xlarge: "r8i.8xlarge";
+  readonly r8i_96xlarge: "r8i.96xlarge";
+  readonly r8i_flex_12xlarge: "r8i-flex.12xlarge";
+  readonly r8i_flex_16xlarge: "r8i-flex.16xlarge";
+  readonly r8i_flex_2xlarge: "r8i-flex.2xlarge";
+  readonly r8i_flex_4xlarge: "r8i-flex.4xlarge";
+  readonly r8i_flex_8xlarge: "r8i-flex.8xlarge";
+  readonly r8i_flex_large: "r8i-flex.large";
+  readonly r8i_flex_xlarge: "r8i-flex.xlarge";
+  readonly r8i_large: "r8i.large";
+  readonly r8i_metal_48xl: "r8i.metal-48xl";
+  readonly r8i_metal_96xl: "r8i.metal-96xl";
+  readonly r8i_xlarge: "r8i.xlarge";
+  readonly t1_micro: "t1.micro";
+  readonly t2_2xlarge: "t2.2xlarge";
+  readonly t2_large: "t2.large";
+  readonly t2_medium: "t2.medium";
+  readonly t2_micro: "t2.micro";
+  readonly t2_nano: "t2.nano";
+  readonly t2_small: "t2.small";
+  readonly t2_xlarge: "t2.xlarge";
+  readonly t3_2xlarge: "t3.2xlarge";
+  readonly t3_large: "t3.large";
+  readonly t3_medium: "t3.medium";
+  readonly t3_micro: "t3.micro";
+  readonly t3_nano: "t3.nano";
+  readonly t3_small: "t3.small";
+  readonly t3_xlarge: "t3.xlarge";
+  readonly t3a_2xlarge: "t3a.2xlarge";
+  readonly t3a_large: "t3a.large";
+  readonly t3a_medium: "t3a.medium";
+  readonly t3a_micro: "t3a.micro";
+  readonly t3a_nano: "t3a.nano";
+  readonly t3a_small: "t3a.small";
+  readonly t3a_xlarge: "t3a.xlarge";
+  readonly t4g_2xlarge: "t4g.2xlarge";
+  readonly t4g_large: "t4g.large";
+  readonly t4g_medium: "t4g.medium";
+  readonly t4g_micro: "t4g.micro";
+  readonly t4g_nano: "t4g.nano";
+  readonly t4g_small: "t4g.small";
+  readonly t4g_xlarge: "t4g.xlarge";
+  readonly trn1_2xlarge: "trn1.2xlarge";
+  readonly trn1_32xlarge: "trn1.32xlarge";
+  readonly trn1n_32xlarge: "trn1n.32xlarge";
+  readonly trn2_3xlarge: "trn2.3xlarge";
+  readonly trn2_48xlarge: "trn2.48xlarge";
+  readonly u7i_12tb_224xlarge: "u7i-12tb.224xlarge";
+  readonly u7i_6tb_112xlarge: "u7i-6tb.112xlarge";
+  readonly u7i_8tb_112xlarge: "u7i-8tb.112xlarge";
+  readonly u7ib_12tb_224xlarge: "u7ib-12tb.224xlarge";
+  readonly u7in_16tb_224xlarge: "u7in-16tb.224xlarge";
+  readonly u7in_24tb_224xlarge: "u7in-24tb.224xlarge";
+  readonly u7in_32tb_224xlarge: "u7in-32tb.224xlarge";
+  readonly u7inh_32tb_480xlarge: "u7inh-32tb.480xlarge";
+  readonly u_12tb1_112xlarge: "u-12tb1.112xlarge";
+  readonly u_12tb1_metal: "u-12tb1.metal";
+  readonly u_18tb1_112xlarge: "u-18tb1.112xlarge";
+  readonly u_18tb1_metal: "u-18tb1.metal";
+  readonly u_24tb1_112xlarge: "u-24tb1.112xlarge";
+  readonly u_24tb1_metal: "u-24tb1.metal";
+  readonly u_3tb1_56xlarge: "u-3tb1.56xlarge";
+  readonly u_6tb1_112xlarge: "u-6tb1.112xlarge";
+  readonly u_6tb1_56xlarge: "u-6tb1.56xlarge";
+  readonly u_6tb1_metal: "u-6tb1.metal";
+  readonly u_9tb1_112xlarge: "u-9tb1.112xlarge";
+  readonly u_9tb1_metal: "u-9tb1.metal";
+  readonly vt1_24xlarge: "vt1.24xlarge";
+  readonly vt1_3xlarge: "vt1.3xlarge";
+  readonly vt1_6xlarge: "vt1.6xlarge";
+  readonly x1_16xlarge: "x1.16xlarge";
+  readonly x1_32xlarge: "x1.32xlarge";
+  readonly x1e_16xlarge: "x1e.16xlarge";
+  readonly x1e_2xlarge: "x1e.2xlarge";
+  readonly x1e_32xlarge: "x1e.32xlarge";
+  readonly x1e_4xlarge: "x1e.4xlarge";
+  readonly x1e_8xlarge: "x1e.8xlarge";
+  readonly x1e_xlarge: "x1e.xlarge";
+  readonly x2gd_12xlarge: "x2gd.12xlarge";
+  readonly x2gd_16xlarge: "x2gd.16xlarge";
+  readonly x2gd_2xlarge: "x2gd.2xlarge";
+  readonly x2gd_4xlarge: "x2gd.4xlarge";
+  readonly x2gd_8xlarge: "x2gd.8xlarge";
+  readonly x2gd_large: "x2gd.large";
+  readonly x2gd_medium: "x2gd.medium";
+  readonly x2gd_metal: "x2gd.metal";
+  readonly x2gd_xlarge: "x2gd.xlarge";
+  readonly x2idn_16xlarge: "x2idn.16xlarge";
+  readonly x2idn_24xlarge: "x2idn.24xlarge";
+  readonly x2idn_32xlarge: "x2idn.32xlarge";
+  readonly x2idn_metal: "x2idn.metal";
+  readonly x2iedn_16xlarge: "x2iedn.16xlarge";
+  readonly x2iedn_24xlarge: "x2iedn.24xlarge";
+  readonly x2iedn_2xlarge: "x2iedn.2xlarge";
+  readonly x2iedn_32xlarge: "x2iedn.32xlarge";
+  readonly x2iedn_4xlarge: "x2iedn.4xlarge";
+  readonly x2iedn_8xlarge: "x2iedn.8xlarge";
+  readonly x2iedn_metal: "x2iedn.metal";
+  readonly x2iedn_xlarge: "x2iedn.xlarge";
+  readonly x2iezn_12xlarge: "x2iezn.12xlarge";
+  readonly x2iezn_2xlarge: "x2iezn.2xlarge";
+  readonly x2iezn_4xlarge: "x2iezn.4xlarge";
+  readonly x2iezn_6xlarge: "x2iezn.6xlarge";
+  readonly x2iezn_8xlarge: "x2iezn.8xlarge";
+  readonly x2iezn_metal: "x2iezn.metal";
+  readonly x8g_12xlarge: "x8g.12xlarge";
+  readonly x8g_16xlarge: "x8g.16xlarge";
+  readonly x8g_24xlarge: "x8g.24xlarge";
+  readonly x8g_2xlarge: "x8g.2xlarge";
+  readonly x8g_48xlarge: "x8g.48xlarge";
+  readonly x8g_4xlarge: "x8g.4xlarge";
+  readonly x8g_8xlarge: "x8g.8xlarge";
+  readonly x8g_large: "x8g.large";
+  readonly x8g_medium: "x8g.medium";
+  readonly x8g_metal_24xl: "x8g.metal-24xl";
+  readonly x8g_metal_48xl: "x8g.metal-48xl";
+  readonly x8g_xlarge: "x8g.xlarge";
+  readonly z1d_12xlarge: "z1d.12xlarge";
+  readonly z1d_2xlarge: "z1d.2xlarge";
+  readonly z1d_3xlarge: "z1d.3xlarge";
+  readonly z1d_6xlarge: "z1d.6xlarge";
+  readonly z1d_large: "z1d.large";
+  readonly z1d_metal: "z1d.metal";
+  readonly z1d_xlarge: "z1d.xlarge";
+};
+export type _InstanceType = (typeof _InstanceType)[keyof typeof _InstanceType];
+export declare const FleetCapacityReservationTenancy: {
+  readonly default: "default";
+};
+export type FleetCapacityReservationTenancy =
+  (typeof FleetCapacityReservationTenancy)[keyof typeof FleetCapacityReservationTenancy];
+export declare const CarrierGatewayState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending: "pending";
+};
+export type CarrierGatewayState =
+  (typeof CarrierGatewayState)[keyof typeof CarrierGatewayState];
+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 declare const EndpointIpAddressType: {
+  readonly dual_stack: "dual-stack";
+  readonly ipv4: "ipv4";
+  readonly ipv6: "ipv6";
+};
+export type EndpointIpAddressType =
+  (typeof EndpointIpAddressType)[keyof typeof EndpointIpAddressType];
+export declare const SelfServicePortal: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+};
+export type SelfServicePortal =
+  (typeof SelfServicePortal)[keyof typeof SelfServicePortal];
+export declare const TrafficIpAddressType: {
+  readonly dual_stack: "dual-stack";
+  readonly ipv4: "ipv4";
+  readonly ipv6: "ipv6";
+};
+export type TrafficIpAddressType =
+  (typeof TrafficIpAddressType)[keyof typeof TrafficIpAddressType];
+export declare const TransportProtocol: {
+  readonly tcp: "tcp";
+  readonly udp: "udp";
+};
+export type TransportProtocol =
+  (typeof TransportProtocol)[keyof typeof TransportProtocol];
+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 declare const ClientVpnRouteStatusCode: {
+  readonly active: "active";
+  readonly creating: "creating";
+  readonly deleting: "deleting";
+  readonly failed: "failed";
+};
+export type ClientVpnRouteStatusCode =
+  (typeof ClientVpnRouteStatusCode)[keyof typeof ClientVpnRouteStatusCode];
+export declare const GatewayType: {
+  readonly ipsec_1: "ipsec.1";
+};
+export type GatewayType = (typeof GatewayType)[keyof typeof GatewayType];
+export declare const BlockPublicAccessMode: {
+  readonly block_bidirectional: "block-bidirectional";
+  readonly block_ingress: "block-ingress";
+  readonly off: "off";
+};
+export type BlockPublicAccessMode =
+  (typeof BlockPublicAccessMode)[keyof typeof BlockPublicAccessMode];
+export declare const HostnameType: {
+  readonly ip_name: "ip-name";
+  readonly resource_name: "resource-name";
+};
+export type HostnameType = (typeof HostnameType)[keyof typeof HostnameType];
+export declare const SubnetState: {
+  readonly available: "available";
+  readonly failed: "failed";
+  readonly failed_insufficient_capacity: "failed-insufficient-capacity";
+  readonly pending: "pending";
+  readonly unavailable: "unavailable";
+};
+export type SubnetState = (typeof SubnetState)[keyof typeof SubnetState];
+export declare const VpcEncryptionControlMode: {
+  readonly enforce: "enforce";
+  readonly monitor: "monitor";
+};
+export type VpcEncryptionControlMode =
+  (typeof VpcEncryptionControlMode)[keyof typeof VpcEncryptionControlMode];
+export declare const VpcEncryptionControlExclusionState: {
+  readonly disabled: "disabled";
+  readonly disabling: "disabling";
+  readonly enabled: "enabled";
+  readonly enabling: "enabling";
+};
+export type VpcEncryptionControlExclusionState =
+  (typeof VpcEncryptionControlExclusionState)[keyof typeof VpcEncryptionControlExclusionState];
+export declare const VpcEncryptionControlState: {
+  readonly available: "available";
+  readonly creating: "creating";
+  readonly delete_failed: "delete-failed";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly enforce_failed: "enforce-failed";
+  readonly enforce_in_progress: "enforce-in-progress";
+  readonly monitor_failed: "monitor-failed";
+  readonly monitor_in_progress: "monitor-in-progress";
+};
+export type VpcEncryptionControlState =
+  (typeof VpcEncryptionControlState)[keyof typeof VpcEncryptionControlState];
+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 declare const MacSystemIntegrityProtectionSettingStatus: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+};
+export type MacSystemIntegrityProtectionSettingStatus =
+  (typeof MacSystemIntegrityProtectionSettingStatus)[keyof typeof MacSystemIntegrityProtectionSettingStatus];
+export declare const MacModificationTaskState: {
+  readonly failed: "failed";
+  readonly inprogress: "in-progress";
+  readonly pending: "pending";
+  readonly successful: "successful";
+};
+export type MacModificationTaskState =
+  (typeof MacModificationTaskState)[keyof typeof MacModificationTaskState];
+export declare const MacModificationTaskType: {
+  readonly SIPModification: "sip-modification";
+  readonly VolumeOwnershipDelegation: "volume-ownership-delegation";
+};
+export type MacModificationTaskType =
+  (typeof MacModificationTaskType)[keyof typeof MacModificationTaskType];
+export declare const FleetExcessCapacityTerminationPolicy: {
+  readonly NO_TERMINATION: "no-termination";
+  readonly TERMINATION: "termination";
+};
+export type FleetExcessCapacityTerminationPolicy =
+  (typeof FleetExcessCapacityTerminationPolicy)[keyof typeof FleetExcessCapacityTerminationPolicy];
+export declare const BareMetal: {
+  readonly EXCLUDED: "excluded";
+  readonly INCLUDED: "included";
+  readonly REQUIRED: "required";
+};
+export type BareMetal = (typeof BareMetal)[keyof typeof BareMetal];
+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 APPLE: "apple";
+  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 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 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 declare const DefaultTargetCapacityType: {
+  readonly CAPACITY_BLOCK: "capacity-block";
+  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 declare const FleetType: {
+  readonly INSTANT: "instant";
+  readonly MAINTAIN: "maintain";
+  readonly REQUEST: "request";
+};
+export type FleetType = (typeof FleetType)[keyof typeof FleetType];
+export declare const InstanceLifecycle: {
+  readonly ON_DEMAND: "on-demand";
+  readonly SPOT: "spot";
+};
+export type InstanceLifecycle =
+  (typeof InstanceLifecycle)[keyof typeof InstanceLifecycle];
+export declare const PlatformValues: {
+  readonly Windows: "Windows";
+};
+export type PlatformValues =
+  (typeof PlatformValues)[keyof typeof PlatformValues];
+export declare const DestinationFileFormat: {
+  readonly parquet: "parquet";
+  readonly plain_text: "plain-text";
+};
+export type DestinationFileFormat =
+  (typeof DestinationFileFormat)[keyof typeof DestinationFileFormat];
+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 RegionalNatGateway: "RegionalNatGateway";
+  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 declare const SnapshotLocationEnum: {
+  readonly LOCAL: "local";
+  readonly REGIONAL: "regional";
+};
+export type SnapshotLocationEnum =
+  (typeof SnapshotLocationEnum)[keyof typeof SnapshotLocationEnum];
+export declare const IpAddressType: {
+  readonly dualstack: "dualstack";
+  readonly ipv4: "ipv4";
+  readonly ipv6: "ipv6";
+};
+export type IpAddressType = (typeof IpAddressType)[keyof typeof IpAddressType];
+export declare const Ec2InstanceConnectEndpointState: {
+  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 update_complete: "update-complete";
+  readonly update_failed: "update-failed";
+  readonly update_in_progress: "update-in-progress";
+};
+export type Ec2InstanceConnectEndpointState =
+  (typeof Ec2InstanceConnectEndpointState)[keyof typeof Ec2InstanceConnectEndpointState];
+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 declare const ExportEnvironment: {
+  readonly citrix: "citrix";
+  readonly microsoft: "microsoft";
+  readonly vmware: "vmware";
+};
+export type ExportEnvironment =
+  (typeof ExportEnvironment)[keyof typeof ExportEnvironment];
+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 declare const IpamMeteredAccount: {
+  readonly ipam_owner: "ipam-owner";
+  readonly resource_owner: "resource-owner";
+};
+export type IpamMeteredAccount =
+  (typeof IpamMeteredAccount)[keyof typeof IpamMeteredAccount];
+export declare const IpamTier: {
+  readonly advanced: "advanced";
+  readonly free: "free";
+};
+export type IpamTier = (typeof IpamTier)[keyof typeof IpamTier];
+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 declare const IpamExternalResourceVerificationTokenState: {
+  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";
+};
+export type IpamExternalResourceVerificationTokenState =
+  (typeof IpamExternalResourceVerificationTokenState)[keyof typeof IpamExternalResourceVerificationTokenState];
+export declare const TokenState: {
+  readonly expired: "expired";
+  readonly valid: "valid";
+};
+export type TokenState = (typeof TokenState)[keyof typeof TokenState];
+export declare const IpamPolicyState: {
+  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 IpamPolicyState =
+  (typeof IpamPolicyState)[keyof typeof IpamPolicyState];
+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 declare const IpamPoolSourceResourceType: {
+  readonly vpc: "vpc";
+};
+export type IpamPoolSourceResourceType =
+  (typeof IpamPoolSourceResourceType)[keyof typeof IpamPoolSourceResourceType];
+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 declare const IpamPrefixListResolverRuleConditionOperation: {
+  readonly equals: "equals";
+  readonly not_equals: "not-equals";
+  readonly subnet_of: "subnet-of";
+};
+export type IpamPrefixListResolverRuleConditionOperation =
+  (typeof IpamPrefixListResolverRuleConditionOperation)[keyof typeof IpamPrefixListResolverRuleConditionOperation];
+export declare const IpamResourceType: {
+  readonly eip: "eip";
+  readonly eni: "eni";
+  readonly ipv6_pool: "ipv6-pool";
+  readonly public_ipv4_pool: "public-ipv4-pool";
+  readonly subnet: "subnet";
+  readonly vpc: "vpc";
+};
+export type IpamResourceType =
+  (typeof IpamResourceType)[keyof typeof IpamResourceType];
+export declare const IpamPrefixListResolverRuleType: {
+  readonly ipam_pool_cidr: "ipam-pool-cidr";
+  readonly ipam_resource_cidr: "ipam-resource-cidr";
+  readonly static_cidr: "static-cidr";
+};
+export type IpamPrefixListResolverRuleType =
+  (typeof IpamPrefixListResolverRuleType)[keyof typeof IpamPrefixListResolverRuleType];
+export declare const IpamPrefixListResolverVersionCreationStatus: {
+  readonly failure: "failure";
+  readonly pending: "pending";
+  readonly success: "success";
+};
+export type IpamPrefixListResolverVersionCreationStatus =
+  (typeof IpamPrefixListResolverVersionCreationStatus)[keyof typeof IpamPrefixListResolverVersionCreationStatus];
+export declare const IpamPrefixListResolverState: {
+  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 IpamPrefixListResolverState =
+  (typeof IpamPrefixListResolverState)[keyof typeof IpamPrefixListResolverState];
+export declare const IpamPrefixListResolverTargetState: {
+  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";
+  readonly sync_complete: "sync-complete";
+  readonly sync_failed: "sync-failed";
+  readonly sync_in_progress: "sync-in-progress";
+};
+export type IpamPrefixListResolverTargetState =
+  (typeof IpamPrefixListResolverTargetState)[keyof typeof IpamPrefixListResolverTargetState];
+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 declare const IpamScopeExternalAuthorityType: {
+  readonly infoblox: "infoblox";
+};
+export type IpamScopeExternalAuthorityType =
+  (typeof IpamScopeExternalAuthorityType)[keyof typeof IpamScopeExternalAuthorityType];
+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 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 declare const CapacityReservationPreference: {
+  readonly capacity_reservations_only: "capacity-reservations-only";
+  readonly none: "none";
+  readonly open: "open";
+};
+export type CapacityReservationPreference =
+  (typeof CapacityReservationPreference)[keyof typeof CapacityReservationPreference];
+export declare const AmdSevSnpSpecification: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+};
+export type AmdSevSnpSpecification =
+  (typeof AmdSevSnpSpecification)[keyof typeof AmdSevSnpSpecification];
+export declare const ShutdownBehavior: {
+  readonly stop: "stop";
+  readonly terminate: "terminate";
+};
+export type ShutdownBehavior =
+  (typeof ShutdownBehavior)[keyof typeof ShutdownBehavior];
+export declare const MarketType: {
+  readonly capacity_block: "capacity-block";
+  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 declare const LaunchTemplateAutoRecoveryState: {
+  readonly default: "default";
+  readonly disabled: "disabled";
+};
+export type LaunchTemplateAutoRecoveryState =
+  (typeof LaunchTemplateAutoRecoveryState)[keyof typeof LaunchTemplateAutoRecoveryState];
+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 declare const InstanceBandwidthWeighting: {
+  readonly DEFAULT: "default";
+  readonly EBS_1: "ebs-1";
+  readonly VPC_1: "vpc-1";
+};
+export type InstanceBandwidthWeighting =
+  (typeof InstanceBandwidthWeighting)[keyof typeof InstanceBandwidthWeighting];
+export declare const LaunchTemplateInstanceMetadataOptionsState: {
+  readonly applied: "applied";
+  readonly pending: "pending";
+};
+export type LaunchTemplateInstanceMetadataOptionsState =
+  (typeof LaunchTemplateInstanceMetadataOptionsState)[keyof typeof LaunchTemplateInstanceMetadataOptionsState];
+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 declare const LocalGatewayRouteTableMode: {
+  readonly coip: "coip";
+  readonly direct_vpc_routing: "direct-vpc-routing";
+};
+export type LocalGatewayRouteTableMode =
+  (typeof LocalGatewayRouteTableMode)[keyof typeof LocalGatewayRouteTableMode];
+export declare const LocalGatewayVirtualInterfaceConfigurationState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending: "pending";
+};
+export type LocalGatewayVirtualInterfaceConfigurationState =
+  (typeof LocalGatewayVirtualInterfaceConfigurationState)[keyof typeof LocalGatewayVirtualInterfaceConfigurationState];
+export declare const LocalGatewayVirtualInterfaceGroupConfigurationState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly incomplete: "incomplete";
+  readonly pending: "pending";
+};
+export type LocalGatewayVirtualInterfaceGroupConfigurationState =
+  (typeof LocalGatewayVirtualInterfaceGroupConfigurationState)[keyof typeof LocalGatewayVirtualInterfaceGroupConfigurationState];
+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 declare const AvailabilityMode: {
+  readonly REGIONAL: "regional";
+  readonly ZONAL: "zonal";
+};
+export type AvailabilityMode =
+  (typeof AvailabilityMode)[keyof typeof AvailabilityMode];
+export declare const ConnectivityType: {
+  readonly PRIVATE: "private";
+  readonly PUBLIC: "public";
+};
+export type ConnectivityType =
+  (typeof ConnectivityType)[keyof typeof ConnectivityType];
+export declare const AutoProvisionZonesState: {
+  readonly DISABLED: "disabled";
+  readonly ENABLED: "enabled";
+};
+export type AutoProvisionZonesState =
+  (typeof AutoProvisionZonesState)[keyof typeof AutoProvisionZonesState];
+export declare const AutoScalingIpsState: {
+  readonly DISABLED: "disabled";
+  readonly ENABLED: "enabled";
+};
+export type AutoScalingIpsState =
+  (typeof AutoScalingIpsState)[keyof typeof AutoScalingIpsState];
+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 declare const RuleAction: {
+  readonly allow: "allow";
+  readonly deny: "deny";
+};
+export type RuleAction = (typeof RuleAction)[keyof typeof RuleAction];
+export declare const NetworkInterfaceCreationType: {
+  readonly branch: "branch";
+  readonly efa: "efa";
+  readonly efa_only: "efa-only";
+  readonly trunk: "trunk";
+};
+export type NetworkInterfaceCreationType =
+  (typeof NetworkInterfaceCreationType)[keyof typeof NetworkInterfaceCreationType];
+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 efa_only: "efa-only";
+  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 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 declare const InterfacePermissionType: {
+  readonly EIP_ASSOCIATE: "EIP-ASSOCIATE";
+  readonly INSTANCE_ATTACH: "INSTANCE-ATTACH";
+};
+export type InterfacePermissionType =
+  (typeof InterfacePermissionType)[keyof typeof InterfacePermissionType];
+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 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 declare const PlacementGroupState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending: "pending";
+};
+export type PlacementGroupState =
+  (typeof PlacementGroupState)[keyof typeof PlacementGroupState];
+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 declare const RouteServerPersistRoutesAction: {
+  readonly DISABLE: "disable";
+  readonly ENABLE: "enable";
+  readonly RESET: "reset";
+};
+export type RouteServerPersistRoutesAction =
+  (typeof RouteServerPersistRoutesAction)[keyof typeof RouteServerPersistRoutesAction];
+export declare const RouteServerPersistRoutesState: {
+  readonly DISABLED: "disabled";
+  readonly DISABLING: "disabling";
+  readonly ENABLED: "enabled";
+  readonly ENABLING: "enabling";
+  readonly MODIFYING: "modifying";
+  readonly RESETTING: "resetting";
+};
+export type RouteServerPersistRoutesState =
+  (typeof RouteServerPersistRoutesState)[keyof typeof RouteServerPersistRoutesState];
+export declare const RouteServerState: {
+  readonly AVAILABLE: "available";
+  readonly DELETED: "deleted";
+  readonly DELETING: "deleting";
+  readonly MODIFYING: "modifying";
+  readonly PENDING: "pending";
+};
+export type RouteServerState =
+  (typeof RouteServerState)[keyof typeof RouteServerState];
+export declare const RouteServerEndpointState: {
+  readonly AVAILABLE: "available";
+  readonly DELETED: "deleted";
+  readonly DELETE_FAILED: "delete-failed";
+  readonly DELETING: "deleting";
+  readonly FAILED: "failed";
+  readonly FAILING: "failing";
+  readonly PENDING: "pending";
+};
+export type RouteServerEndpointState =
+  (typeof RouteServerEndpointState)[keyof typeof RouteServerEndpointState];
+export declare const RouteServerPeerLivenessMode: {
+  readonly BFD: "bfd";
+  readonly BGP_KEEPALIVE: "bgp-keepalive";
+};
+export type RouteServerPeerLivenessMode =
+  (typeof RouteServerPeerLivenessMode)[keyof typeof RouteServerPeerLivenessMode];
+export declare const RouteServerBfdState: {
+  readonly DOWN: "down";
+  readonly UP: "up";
+};
+export type RouteServerBfdState =
+  (typeof RouteServerBfdState)[keyof typeof RouteServerBfdState];
+export declare const RouteServerBgpState: {
+  readonly DOWN: "down";
+  readonly UP: "up";
+};
+export type RouteServerBgpState =
+  (typeof RouteServerBgpState)[keyof typeof RouteServerBgpState];
+export declare const RouteServerPeerState: {
+  readonly AVAILABLE: "available";
+  readonly DELETED: "deleted";
+  readonly DELETING: "deleting";
+  readonly FAILED: "failed";
+  readonly FAILING: "failing";
+  readonly PENDING: "pending";
+};
+export type RouteServerPeerState =
+  (typeof RouteServerPeerState)[keyof typeof RouteServerPeerState];
+export declare const RouteOrigin: {
+  readonly Advertisement: "Advertisement";
+  readonly CreateRoute: "CreateRoute";
+  readonly CreateRouteTable: "CreateRouteTable";
+  readonly EnableVgwRoutePropagation: "EnableVgwRoutePropagation";
+};
+export type RouteOrigin = (typeof RouteOrigin)[keyof typeof RouteOrigin];
+export declare const RouteState: {
+  readonly active: "active";
+  readonly blackhole: "blackhole";
+  readonly filtered: "filtered";
+};
+export type RouteState = (typeof RouteState)[keyof typeof RouteState];
+export declare const SnapshotState: {
+  readonly completed: "completed";
+  readonly error: "error";
+  readonly pending: "pending";
+  readonly recoverable: "recoverable";
+  readonly recovering: "recovering";
+};
+export type SnapshotState = (typeof SnapshotState)[keyof typeof SnapshotState];
+export declare const StorageTier: {
+  readonly archive: "archive";
+  readonly standard: "standard";
+};
+export type StorageTier = (typeof StorageTier)[keyof typeof StorageTier];
+export declare const TransferType: {
+  readonly standard: "standard";
+  readonly time_based: "time-based";
+};
+export type TransferType = (typeof TransferType)[keyof typeof TransferType];
+export declare const CopyTagsFromSource: {
+  readonly volume: "volume";
+};
+export type CopyTagsFromSource =
+  (typeof CopyTagsFromSource)[keyof typeof CopyTagsFromSource];
+export declare const DatafeedSubscriptionState: {
+  readonly Active: "Active";
+  readonly Inactive: "Inactive";
+};
+export type DatafeedSubscriptionState =
+  (typeof DatafeedSubscriptionState)[keyof typeof DatafeedSubscriptionState];
+export declare const SubnetCidrReservationType: {
+  readonly explicit: "explicit";
+  readonly prefix: "prefix";
+};
+export type SubnetCidrReservationType =
+  (typeof SubnetCidrReservationType)[keyof typeof SubnetCidrReservationType];
+export declare const TrafficMirrorRuleAction: {
+  readonly accept: "accept";
+  readonly reject: "reject";
+};
+export type TrafficMirrorRuleAction =
+  (typeof TrafficMirrorRuleAction)[keyof typeof TrafficMirrorRuleAction];
+export declare const TrafficDirection: {
+  readonly egress: "egress";
+  readonly ingress: "ingress";
+};
+export type TrafficDirection =
+  (typeof TrafficDirection)[keyof typeof TrafficDirection];
+export declare const TrafficMirrorNetworkService: {
+  readonly amazon_dns: "amazon-dns";
+};
+export type TrafficMirrorNetworkService =
+  (typeof TrafficMirrorNetworkService)[keyof typeof TrafficMirrorNetworkService];
+export declare const TrafficMirrorTargetType: {
+  readonly gateway_load_balancer_endpoint: "gateway-load-balancer-endpoint";
+  readonly network_interface: "network-interface";
+  readonly network_load_balancer: "network-load-balancer";
+};
+export type TrafficMirrorTargetType =
+  (typeof TrafficMirrorTargetType)[keyof typeof TrafficMirrorTargetType];
+export declare const AutoAcceptSharedAttachmentsValue: {
+  readonly disable: "disable";
+  readonly enable: "enable";
+};
+export type AutoAcceptSharedAttachmentsValue =
+  (typeof AutoAcceptSharedAttachmentsValue)[keyof typeof AutoAcceptSharedAttachmentsValue];
+export declare const DefaultRouteTableAssociationValue: {
+  readonly disable: "disable";
+  readonly enable: "enable";
+};
+export type DefaultRouteTableAssociationValue =
+  (typeof DefaultRouteTableAssociationValue)[keyof typeof DefaultRouteTableAssociationValue];
+export declare const DefaultRouteTablePropagationValue: {
+  readonly disable: "disable";
+  readonly enable: "enable";
+};
+export type DefaultRouteTablePropagationValue =
+  (typeof DefaultRouteTablePropagationValue)[keyof typeof DefaultRouteTablePropagationValue];
+export declare const MulticastSupportValue: {
+  readonly disable: "disable";
+  readonly enable: "enable";
+};
+export type MulticastSupportValue =
+  (typeof MulticastSupportValue)[keyof typeof MulticastSupportValue];
+export declare const VpnEcmpSupportValue: {
+  readonly disable: "disable";
+  readonly enable: "enable";
+};
+export type VpnEcmpSupportValue =
+  (typeof VpnEcmpSupportValue)[keyof typeof VpnEcmpSupportValue];
+export declare const TransitGatewayState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly modifying: "modifying";
+  readonly pending: "pending";
+};
+export type TransitGatewayState =
+  (typeof TransitGatewayState)[keyof typeof TransitGatewayState];
+export declare const ProtocolValue: {
+  readonly gre: "gre";
+};
+export type ProtocolValue = (typeof ProtocolValue)[keyof typeof ProtocolValue];
+export declare const BgpStatus: {
+  readonly down: "down";
+  readonly up: "up";
+};
+export type BgpStatus = (typeof BgpStatus)[keyof typeof BgpStatus];
+export declare const TransitGatewayConnectPeerState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending: "pending";
+};
+export type TransitGatewayConnectPeerState =
+  (typeof TransitGatewayConnectPeerState)[keyof typeof TransitGatewayConnectPeerState];
+export declare const AutoAcceptSharedAssociationsValue: {
+  readonly disable: "disable";
+  readonly enable: "enable";
+};
+export type AutoAcceptSharedAssociationsValue =
+  (typeof AutoAcceptSharedAssociationsValue)[keyof typeof AutoAcceptSharedAssociationsValue];
+export declare const Igmpv2SupportValue: {
+  readonly disable: "disable";
+  readonly enable: "enable";
+};
+export type Igmpv2SupportValue =
+  (typeof Igmpv2SupportValue)[keyof typeof Igmpv2SupportValue];
+export declare const StaticSourcesSupportValue: {
+  readonly disable: "disable";
+  readonly enable: "enable";
+};
+export type StaticSourcesSupportValue =
+  (typeof StaticSourcesSupportValue)[keyof typeof StaticSourcesSupportValue];
+export declare const TransitGatewayMulticastDomainState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending: "pending";
+};
+export type TransitGatewayMulticastDomainState =
+  (typeof TransitGatewayMulticastDomainState)[keyof typeof TransitGatewayMulticastDomainState];
+export declare const TransitGatewayPolicyTableState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending: "pending";
+};
+export type TransitGatewayPolicyTableState =
+  (typeof TransitGatewayPolicyTableState)[keyof typeof TransitGatewayPolicyTableState];
+export declare const TransitGatewayPrefixListReferenceState: {
+  readonly available: "available";
+  readonly deleting: "deleting";
+  readonly modifying: "modifying";
+  readonly pending: "pending";
+};
+export type TransitGatewayPrefixListReferenceState =
+  (typeof TransitGatewayPrefixListReferenceState)[keyof typeof TransitGatewayPrefixListReferenceState];
+export declare const TransitGatewayRouteState: {
+  readonly active: "active";
+  readonly blackhole: "blackhole";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending: "pending";
+};
+export type TransitGatewayRouteState =
+  (typeof TransitGatewayRouteState)[keyof typeof TransitGatewayRouteState];
+export declare const TransitGatewayRouteType: {
+  readonly propagated: "propagated";
+  readonly static: "static";
+};
+export type TransitGatewayRouteType =
+  (typeof TransitGatewayRouteType)[keyof typeof TransitGatewayRouteType];
+export declare const TransitGatewayRouteTableState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending: "pending";
+};
+export type TransitGatewayRouteTableState =
+  (typeof TransitGatewayRouteTableState)[keyof typeof TransitGatewayRouteTableState];
+export declare const TransitGatewayRouteTableAnnouncementDirection: {
+  readonly incoming: "incoming";
+  readonly outgoing: "outgoing";
+};
+export type TransitGatewayRouteTableAnnouncementDirection =
+  (typeof TransitGatewayRouteTableAnnouncementDirection)[keyof typeof TransitGatewayRouteTableAnnouncementDirection];
+export declare const TransitGatewayRouteTableAnnouncementState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly failed: "failed";
+  readonly failing: "failing";
+  readonly pending: "pending";
+};
+export type TransitGatewayRouteTableAnnouncementState =
+  (typeof TransitGatewayRouteTableAnnouncementState)[keyof typeof TransitGatewayRouteTableAnnouncementState];
+export declare const VerifiedAccessEndpointAttachmentType: {
+  readonly vpc: "vpc";
+};
+export type VerifiedAccessEndpointAttachmentType =
+  (typeof VerifiedAccessEndpointAttachmentType)[keyof typeof VerifiedAccessEndpointAttachmentType];
+export declare const VerifiedAccessEndpointProtocol: {
+  readonly http: "http";
+  readonly https: "https";
+  readonly tcp: "tcp";
+};
+export type VerifiedAccessEndpointProtocol =
+  (typeof VerifiedAccessEndpointProtocol)[keyof typeof VerifiedAccessEndpointProtocol];
+export declare const VerifiedAccessEndpointType: {
+  readonly cidr: "cidr";
+  readonly load_balancer: "load-balancer";
+  readonly network_interface: "network-interface";
+  readonly rds: "rds";
+};
+export type VerifiedAccessEndpointType =
+  (typeof VerifiedAccessEndpointType)[keyof typeof VerifiedAccessEndpointType];
+export declare const VerifiedAccessEndpointStatusCode: {
+  readonly active: "active";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending: "pending";
+  readonly updating: "updating";
+};
+export type VerifiedAccessEndpointStatusCode =
+  (typeof VerifiedAccessEndpointStatusCode)[keyof typeof VerifiedAccessEndpointStatusCode];
+export declare const InternetGatewayExclusionMode: {
+  readonly allow_bidirectional: "allow-bidirectional";
+  readonly allow_egress: "allow-egress";
+};
+export type InternetGatewayExclusionMode =
+  (typeof InternetGatewayExclusionMode)[keyof typeof InternetGatewayExclusionMode];
+export declare const VpcBlockPublicAccessExclusionState: {
+  readonly create_complete: "create-complete";
+  readonly create_failed: "create-failed";
+  readonly create_in_progress: "create-in-progress";
+  readonly delete_complete: "delete-complete";
+  readonly delete_in_progress: "delete-in-progress";
+  readonly disable_complete: "disable-complete";
+  readonly disable_in_progress: "disable-in-progress";
+  readonly update_complete: "update-complete";
+  readonly update_failed: "update-failed";
+  readonly update_in_progress: "update-in-progress";
+};
+export type VpcBlockPublicAccessExclusionState =
+  (typeof VpcBlockPublicAccessExclusionState)[keyof typeof VpcBlockPublicAccessExclusionState];
+export declare const DnsRecordIpType: {
+  readonly dualstack: "dualstack";
+  readonly ipv4: "ipv4";
+  readonly ipv6: "ipv6";
+  readonly service_defined: "service-defined";
+};
+export type DnsRecordIpType =
+  (typeof DnsRecordIpType)[keyof typeof DnsRecordIpType];
+export declare const VpcEndpointType: {
+  readonly Gateway: "Gateway";
+  readonly GatewayLoadBalancer: "GatewayLoadBalancer";
+  readonly Interface: "Interface";
+  readonly Resource: "Resource";
+  readonly ServiceNetwork: "ServiceNetwork";
+};
+export type VpcEndpointType =
+  (typeof VpcEndpointType)[keyof typeof VpcEndpointType];
+export declare const State: {
+  readonly Available: "Available";
+  readonly Deleted: "Deleted";
+  readonly Deleting: "Deleting";
+  readonly Expired: "Expired";
+  readonly Failed: "Failed";
+  readonly Partial: "Partial";
+  readonly Pending: "Pending";
+  readonly PendingAcceptance: "PendingAcceptance";
+  readonly Rejected: "Rejected";
+};
+export type State = (typeof State)[keyof typeof State];
+export declare const ConnectionNotificationState: {
+  readonly Disabled: "Disabled";
+  readonly Enabled: "Enabled";
+};
+export type ConnectionNotificationState =
+  (typeof ConnectionNotificationState)[keyof typeof ConnectionNotificationState];
+export declare const ConnectionNotificationType: {
+  readonly Topic: "Topic";
+};
+export type ConnectionNotificationType =
+  (typeof ConnectionNotificationType)[keyof typeof ConnectionNotificationType];
+export declare const PayerResponsibility: {
+  readonly ServiceOwner: "ServiceOwner";
+};
+export type PayerResponsibility =
+  (typeof PayerResponsibility)[keyof typeof PayerResponsibility];
+export declare const DnsNameState: {
+  readonly Failed: "failed";
+  readonly PendingVerification: "pendingVerification";
+  readonly Verified: "verified";
+};
+export type DnsNameState = (typeof DnsNameState)[keyof typeof DnsNameState];
+export declare const ServiceState: {
+  readonly Available: "Available";
+  readonly Deleted: "Deleted";
+  readonly Deleting: "Deleting";
+  readonly Failed: "Failed";
+  readonly Pending: "Pending";
+};
+export type ServiceState = (typeof ServiceState)[keyof typeof ServiceState];
+export declare const ServiceType: {
+  readonly Gateway: "Gateway";
+  readonly GatewayLoadBalancer: "GatewayLoadBalancer";
+  readonly Interface: "Interface";
+};
+export type ServiceType = (typeof ServiceType)[keyof typeof ServiceType];
+export declare const ServiceConnectivityType: {
+  readonly ipv4: "ipv4";
+  readonly ipv6: "ipv6";
+};
+export type ServiceConnectivityType =
+  (typeof ServiceConnectivityType)[keyof typeof ServiceConnectivityType];
+export declare const VpnConcentratorType: {
+  readonly ipsec_1: "ipsec.1";
+};
+export type VpnConcentratorType =
+  (typeof VpnConcentratorType)[keyof typeof VpnConcentratorType];
+export declare const VpnTunnelBandwidth: {
+  readonly large: "large";
+  readonly standard: "standard";
+};
+export type VpnTunnelBandwidth =
+  (typeof VpnTunnelBandwidth)[keyof typeof VpnTunnelBandwidth];
+export declare const TunnelInsideIpVersion: {
+  readonly ipv4: "ipv4";
+  readonly ipv6: "ipv6";
+};
+export type TunnelInsideIpVersion =
+  (typeof TunnelInsideIpVersion)[keyof typeof TunnelInsideIpVersion];
+export declare const GatewayAssociationState: {
+  readonly associated: "associated";
+  readonly associating: "associating";
+  readonly disassociating: "disassociating";
+  readonly not_associated: "not-associated";
+};
+export type GatewayAssociationState =
+  (typeof GatewayAssociationState)[keyof typeof GatewayAssociationState];
+export declare const VpnStaticRouteSource: {
+  readonly Static: "Static";
+};
+export type VpnStaticRouteSource =
+  (typeof VpnStaticRouteSource)[keyof typeof VpnStaticRouteSource];
+export declare const VpnState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending: "pending";
+};
+export type VpnState = (typeof VpnState)[keyof typeof VpnState];
+export declare const TelemetryStatus: {
+  readonly DOWN: "DOWN";
+  readonly UP: "UP";
+};
+export type TelemetryStatus =
+  (typeof TelemetryStatus)[keyof typeof TelemetryStatus];
+export declare const FleetStateCode: {
+  readonly ACTIVE: "active";
+  readonly DELETED: "deleted";
+  readonly DELETED_RUNNING: "deleted_running";
+  readonly DELETED_TERMINATING_INSTANCES: "deleted_terminating";
+  readonly FAILED: "failed";
+  readonly MODIFYING: "modifying";
+  readonly SUBMITTED: "submitted";
+};
+export type FleetStateCode =
+  (typeof FleetStateCode)[keyof typeof FleetStateCode];
+export declare const DeleteFleetErrorCode: {
+  readonly FLEET_ID_DOES_NOT_EXIST: "fleetIdDoesNotExist";
+  readonly FLEET_ID_MALFORMED: "fleetIdMalformed";
+  readonly FLEET_NOT_IN_DELETABLE_STATE: "fleetNotInDeletableState";
+  readonly UNEXPECTED_ERROR: "unexpectedError";
+};
+export type DeleteFleetErrorCode =
+  (typeof DeleteFleetErrorCode)[keyof typeof DeleteFleetErrorCode];
+export declare const LaunchTemplateErrorCode: {
+  readonly LAUNCH_TEMPLATE_ID_DOES_NOT_EXIST: "launchTemplateIdDoesNotExist";
+  readonly LAUNCH_TEMPLATE_ID_MALFORMED: "launchTemplateIdMalformed";
+  readonly LAUNCH_TEMPLATE_NAME_DOES_NOT_EXIST: "launchTemplateNameDoesNotExist";
+  readonly LAUNCH_TEMPLATE_NAME_MALFORMED: "launchTemplateNameMalformed";
+  readonly LAUNCH_TEMPLATE_VERSION_DOES_NOT_EXIST: "launchTemplateVersionDoesNotExist";
+  readonly UNEXPECTED_ERROR: "unexpectedError";
+};
+export type LaunchTemplateErrorCode =
+  (typeof LaunchTemplateErrorCode)[keyof typeof LaunchTemplateErrorCode];
+export declare const DeleteQueuedReservedInstancesErrorCode: {
+  readonly RESERVED_INSTANCES_ID_INVALID: "reserved-instances-id-invalid";
+  readonly RESERVED_INSTANCES_NOT_IN_QUEUED_STATE: "reserved-instances-not-in-queued-state";
+  readonly UNEXPECTED_ERROR: "unexpected-error";
+};
+export type DeleteQueuedReservedInstancesErrorCode =
+  (typeof DeleteQueuedReservedInstancesErrorCode)[keyof typeof DeleteQueuedReservedInstancesErrorCode];
+export declare const AsnState: {
+  readonly deprovisioned: "deprovisioned";
+  readonly failed_deprovision: "failed-deprovision";
+  readonly failed_provision: "failed-provision";
+  readonly pending_deprovision: "pending-deprovision";
+  readonly pending_provision: "pending-provision";
+  readonly provisioned: "provisioned";
+};
+export type AsnState = (typeof AsnState)[keyof typeof AsnState];
+export declare const IpamPoolCidrFailureCode: {
+  readonly cidr_not_available: "cidr-not-available";
+  readonly limit_exceeded: "limit-exceeded";
+};
+export type IpamPoolCidrFailureCode =
+  (typeof IpamPoolCidrFailureCode)[keyof typeof IpamPoolCidrFailureCode];
+export declare const IpamPoolCidrState: {
+  readonly deprovisioned: "deprovisioned";
+  readonly failed_deprovision: "failed-deprovision";
+  readonly failed_import: "failed-import";
+  readonly failed_provision: "failed-provision";
+  readonly pending_deprovision: "pending-deprovision";
+  readonly pending_import: "pending-import";
+  readonly pending_provision: "pending-provision";
+  readonly provisioned: "provisioned";
+};
+export type IpamPoolCidrState =
+  (typeof IpamPoolCidrState)[keyof typeof IpamPoolCidrState];
+export declare const SnapshotReturnCodes: {
+  readonly ERROR_CODE_CLIENT_ERROR: "client-error";
+  readonly ERROR_CODE_INTERNAL_ERROR: "internal-error";
+  readonly ERROR_MISSING_PERMISSIONS: "missing-permissions";
+  readonly SUCCESS: "success";
+  readonly WARN_SKIPPED: "skipped";
+};
+export type SnapshotReturnCodes =
+  (typeof SnapshotReturnCodes)[keyof typeof SnapshotReturnCodes];
+export declare const AvailabilityZoneOptInStatus: {
+  readonly not_opted_in: "not-opted-in";
+  readonly opt_in_not_required: "opt-in-not-required";
+  readonly opted_in: "opted-in";
+};
+export type AvailabilityZoneOptInStatus =
+  (typeof AvailabilityZoneOptInStatus)[keyof typeof AvailabilityZoneOptInStatus];
+export declare const AvailabilityZoneState: {
+  readonly available: "available";
+  readonly constrained: "constrained";
+  readonly impaired: "impaired";
+  readonly information: "information";
+  readonly unavailable: "unavailable";
+};
+export type AvailabilityZoneState =
+  (typeof AvailabilityZoneState)[keyof typeof AvailabilityZoneState];
+export declare const MetricType: {
+  readonly aggregate_latency: "aggregate-latency";
+};
+export type MetricType = (typeof MetricType)[keyof typeof MetricType];
+export declare const PeriodType: {
+  readonly fifteen_minutes: "fifteen-minutes";
+  readonly five_minutes: "five-minutes";
+  readonly one_day: "one-day";
+  readonly one_hour: "one-hour";
+  readonly one_week: "one-week";
+  readonly three_hours: "three-hours";
+};
+export type PeriodType = (typeof PeriodType)[keyof typeof PeriodType];
+export declare const StatisticType: {
+  readonly p50: "p50";
+};
+export type StatisticType = (typeof StatisticType)[keyof typeof StatisticType];
+export declare const CapacityBlockExtensionStatus: {
+  readonly PAYMENT_FAILED: "payment-failed";
+  readonly PAYMENT_PENDING: "payment-pending";
+  readonly PAYMENT_SUCCEEDED: "payment-succeeded";
+};
+export type CapacityBlockExtensionStatus =
+  (typeof CapacityBlockExtensionStatus)[keyof typeof CapacityBlockExtensionStatus];
+export declare const CapacityBlockResourceState: {
+  readonly active: "active";
+  readonly cancelled: "cancelled";
+  readonly expired: "expired";
+  readonly failed: "failed";
+  readonly payment_failed: "payment-failed";
+  readonly payment_pending: "payment-pending";
+  readonly scheduled: "scheduled";
+  readonly unavailable: "unavailable";
+};
+export type CapacityBlockResourceState =
+  (typeof CapacityBlockResourceState)[keyof typeof CapacityBlockResourceState];
+export declare const CapacityBlockInterconnectStatus: {
+  readonly impaired: "impaired";
+  readonly insufficient_data: "insufficient-data";
+  readonly ok: "ok";
+};
+export type CapacityBlockInterconnectStatus =
+  (typeof CapacityBlockInterconnectStatus)[keyof typeof CapacityBlockInterconnectStatus];
+export declare const CapacityManagerDataExportStatus: {
+  readonly DELIVERED: "delivered";
+  readonly FAILED: "failed";
+  readonly IN_PROGRESS: "in-progress";
+  readonly PENDING: "pending";
+};
+export type CapacityManagerDataExportStatus =
+  (typeof CapacityManagerDataExportStatus)[keyof typeof CapacityManagerDataExportStatus];
+export declare const CallerRole: {
+  readonly odcr_owner: "odcr-owner";
+  readonly unused_reservation_billing_owner: "unused-reservation-billing-owner";
+};
+export type CallerRole = (typeof CallerRole)[keyof typeof CallerRole];
+export declare const CapacityReservationBillingRequestStatus: {
+  readonly accepted: "accepted";
+  readonly cancelled: "cancelled";
+  readonly expired: "expired";
+  readonly pending: "pending";
+  readonly rejected: "rejected";
+  readonly revoked: "revoked";
+};
+export type CapacityReservationBillingRequestStatus =
+  (typeof CapacityReservationBillingRequestStatus)[keyof typeof CapacityReservationBillingRequestStatus];
+export declare const ClientVpnConnectionStatusCode: {
+  readonly active: "active";
+  readonly failed_to_terminate: "failed-to-terminate";
+  readonly terminated: "terminated";
+  readonly terminating: "terminating";
+};
+export type ClientVpnConnectionStatusCode =
+  (typeof ClientVpnConnectionStatusCode)[keyof typeof ClientVpnConnectionStatusCode];
+export declare const AssociatedNetworkType: {
+  readonly vpc: "vpc";
+};
+export type AssociatedNetworkType =
+  (typeof AssociatedNetworkType)[keyof typeof AssociatedNetworkType];
+export declare const ClientVpnEndpointAttributeStatusCode: {
+  readonly applied: "applied";
+  readonly applying: "applying";
+};
+export type ClientVpnEndpointAttributeStatusCode =
+  (typeof ClientVpnEndpointAttributeStatusCode)[keyof typeof ClientVpnEndpointAttributeStatusCode];
+export declare const VpnProtocol: {
+  readonly openvpn: "openvpn";
+};
+export type VpnProtocol = (typeof VpnProtocol)[keyof typeof VpnProtocol];
+export declare const ConversionTaskState: {
+  readonly active: "active";
+  readonly cancelled: "cancelled";
+  readonly cancelling: "cancelling";
+  readonly completed: "completed";
+};
+export type ConversionTaskState =
+  (typeof ConversionTaskState)[keyof typeof ConversionTaskState];
+export declare const ReportState: {
+  readonly cancelled: "cancelled";
+  readonly complete: "complete";
+  readonly error: "error";
+  readonly running: "running";
+};
+export type ReportState = (typeof ReportState)[keyof typeof ReportState];
+export declare const ElasticGpuStatus: {
+  readonly Impaired: "IMPAIRED";
+  readonly Ok: "OK";
+};
+export type ElasticGpuStatus =
+  (typeof ElasticGpuStatus)[keyof typeof ElasticGpuStatus];
+export declare const ElasticGpuState: {
+  readonly Attached: "ATTACHED";
+};
+export type ElasticGpuState =
+  (typeof ElasticGpuState)[keyof typeof ElasticGpuState];
+export declare const FastLaunchResourceType: {
+  readonly SNAPSHOT: "snapshot";
+};
+export type FastLaunchResourceType =
+  (typeof FastLaunchResourceType)[keyof typeof FastLaunchResourceType];
+export declare const FastLaunchStateCode: {
+  readonly disabling: "disabling";
+  readonly disabling_failed: "disabling-failed";
+  readonly enabled: "enabled";
+  readonly enabled_failed: "enabled-failed";
+  readonly enabling: "enabling";
+  readonly enabling_failed: "enabling-failed";
+};
+export type FastLaunchStateCode =
+  (typeof FastLaunchStateCode)[keyof typeof FastLaunchStateCode];
+export declare const FastSnapshotRestoreStateCode: {
+  readonly disabled: "disabled";
+  readonly disabling: "disabling";
+  readonly enabled: "enabled";
+  readonly enabling: "enabling";
+  readonly optimizing: "optimizing";
+};
+export type FastSnapshotRestoreStateCode =
+  (typeof FastSnapshotRestoreStateCode)[keyof typeof FastSnapshotRestoreStateCode];
+export declare const FleetEventType: {
+  readonly FLEET_CHANGE: "fleet-change";
+  readonly INSTANCE_CHANGE: "instance-change";
+  readonly SERVICE_ERROR: "service-error";
+};
+export type FleetEventType =
+  (typeof FleetEventType)[keyof typeof FleetEventType];
+export declare const FleetActivityStatus: {
+  readonly ERROR: "error";
+  readonly FULFILLED: "fulfilled";
+  readonly PENDING_FULFILLMENT: "pending_fulfillment";
+  readonly PENDING_TERMINATION: "pending_termination";
+};
+export type FleetActivityStatus =
+  (typeof FleetActivityStatus)[keyof typeof FleetActivityStatus];
+export declare const FpgaImageAttributeName: {
+  readonly description: "description";
+  readonly loadPermission: "loadPermission";
+  readonly name: "name";
+  readonly productCodes: "productCodes";
+};
+export type FpgaImageAttributeName =
+  (typeof FpgaImageAttributeName)[keyof typeof FpgaImageAttributeName];
+export declare const PermissionGroup: {
+  readonly all: "all";
+};
+export type PermissionGroup =
+  (typeof PermissionGroup)[keyof typeof PermissionGroup];
+export declare const ProductCodeValues: {
+  readonly devpay: "devpay";
+  readonly marketplace: "marketplace";
+};
+export type ProductCodeValues =
+  (typeof ProductCodeValues)[keyof typeof ProductCodeValues];
+export declare const FpgaImageStateCode: {
+  readonly available: "available";
+  readonly failed: "failed";
+  readonly pending: "pending";
+  readonly unavailable: "unavailable";
+};
+export type FpgaImageStateCode =
+  (typeof FpgaImageStateCode)[keyof typeof FpgaImageStateCode];
+export declare const PaymentOption: {
+  readonly ALL_UPFRONT: "AllUpfront";
+  readonly NO_UPFRONT: "NoUpfront";
+  readonly PARTIAL_UPFRONT: "PartialUpfront";
+};
+export type PaymentOption = (typeof PaymentOption)[keyof typeof PaymentOption];
+export declare const ReservationState: {
+  readonly ACTIVE: "active";
+  readonly CANCELLED: "cancelled";
+  readonly DELAYED: "delayed";
+  readonly EXPIRED: "expired";
+  readonly FAILED: "failed";
+  readonly PAYMENT_FAILED: "payment-failed";
+  readonly PAYMENT_PENDING: "payment-pending";
+  readonly PENDING: "pending";
+  readonly RETIRED: "retired";
+  readonly SCHEDULED: "scheduled";
+  readonly UNSUPPORTED: "unsupported";
+};
+export type ReservationState =
+  (typeof ReservationState)[keyof typeof ReservationState];
+export declare const ImageAttributeName: {
+  readonly blockDeviceMapping: "blockDeviceMapping";
+  readonly bootMode: "bootMode";
+  readonly deregistrationProtection: "deregistrationProtection";
+  readonly description: "description";
+  readonly imdsSupport: "imdsSupport";
+  readonly kernel: "kernel";
+  readonly lastLaunchedTime: "lastLaunchedTime";
+  readonly launchPermission: "launchPermission";
+  readonly productCodes: "productCodes";
+  readonly ramdisk: "ramdisk";
+  readonly sriovNetSupport: "sriovNetSupport";
+  readonly tpmSupport: "tpmSupport";
+  readonly uefiData: "uefiData";
+};
+export type ImageAttributeName =
+  (typeof ImageAttributeName)[keyof typeof ImageAttributeName];
+export declare const ImageReferenceResourceType: {
+  readonly EC2_INSTANCE: "ec2:Instance";
+  readonly EC2_LAUNCH_TEMPLATE: "ec2:LaunchTemplate";
+  readonly IMAGE_BUILDER_CONTAINER_RECIPE: "imagebuilder:ContainerRecipe";
+  readonly IMAGE_BUILDER_IMAGE_RECIPE: "imagebuilder:ImageRecipe";
+  readonly SSM_PARAMETER: "ssm:Parameter";
+};
+export type ImageReferenceResourceType =
+  (typeof ImageReferenceResourceType)[keyof typeof ImageReferenceResourceType];
+export declare const ImageReferenceOptionName: {
+  readonly STATE_NAME: "state-name";
+  readonly VERSION_DEPTH: "version-depth";
+};
+export type ImageReferenceOptionName =
+  (typeof ImageReferenceOptionName)[keyof typeof ImageReferenceOptionName];
+export declare const ArchitectureValues: {
+  readonly arm64: "arm64";
+  readonly arm64_mac: "arm64_mac";
+  readonly i386: "i386";
+  readonly x86_64: "x86_64";
+  readonly x86_64_mac: "x86_64_mac";
+};
+export type ArchitectureValues =
+  (typeof ArchitectureValues)[keyof typeof ArchitectureValues];
+export declare const BootModeValues: {
+  readonly legacy_bios: "legacy-bios";
+  readonly uefi: "uefi";
+  readonly uefi_preferred: "uefi-preferred";
+};
+export type BootModeValues =
+  (typeof BootModeValues)[keyof typeof BootModeValues];
+export declare const HypervisorType: {
+  readonly ovm: "ovm";
+  readonly xen: "xen";
+};
+export type HypervisorType =
+  (typeof HypervisorType)[keyof typeof HypervisorType];
+export declare const ImageTypeValues: {
+  readonly kernel: "kernel";
+  readonly machine: "machine";
+  readonly ramdisk: "ramdisk";
+};
+export type ImageTypeValues =
+  (typeof ImageTypeValues)[keyof typeof ImageTypeValues];
+export declare const ImdsSupportValues: {
+  readonly v2_0: "v2.0";
+};
+export type ImdsSupportValues =
+  (typeof ImdsSupportValues)[keyof typeof ImdsSupportValues];
+export declare const DeviceType: {
+  readonly ebs: "ebs";
+  readonly instance_store: "instance-store";
+};
+export type DeviceType = (typeof DeviceType)[keyof typeof DeviceType];
+export declare const ImageState: {
+  readonly available: "available";
+  readonly deregistered: "deregistered";
+  readonly disabled: "disabled";
+  readonly error: "error";
+  readonly failed: "failed";
+  readonly invalid: "invalid";
+  readonly pending: "pending";
+  readonly transient: "transient";
+};
+export type ImageState = (typeof ImageState)[keyof typeof ImageState];
+export declare const TpmSupportValues: {
+  readonly v2_0: "v2.0";
+};
+export type TpmSupportValues =
+  (typeof TpmSupportValues)[keyof typeof TpmSupportValues];
+export declare const VirtualizationType: {
+  readonly hvm: "hvm";
+  readonly paravirtual: "paravirtual";
+};
+export type VirtualizationType =
+  (typeof VirtualizationType)[keyof typeof VirtualizationType];
+export declare const InstanceAttributeName: {
+  readonly blockDeviceMapping: "blockDeviceMapping";
+  readonly disableApiStop: "disableApiStop";
+  readonly disableApiTermination: "disableApiTermination";
+  readonly ebsOptimized: "ebsOptimized";
+  readonly enaSupport: "enaSupport";
+  readonly enclaveOptions: "enclaveOptions";
+  readonly groupSet: "groupSet";
+  readonly instanceInitiatedShutdownBehavior: "instanceInitiatedShutdownBehavior";
+  readonly instanceType: "instanceType";
+  readonly kernel: "kernel";
+  readonly productCodes: "productCodes";
+  readonly ramdisk: "ramdisk";
+  readonly rootDeviceName: "rootDeviceName";
+  readonly sourceDestCheck: "sourceDestCheck";
+  readonly sriovNetSupport: "sriovNetSupport";
+  readonly userData: "userData";
+};
+export type InstanceAttributeName =
+  (typeof InstanceAttributeName)[keyof typeof InstanceAttributeName];
+export declare const InstanceStateName: {
+  readonly pending: "pending";
+  readonly running: "running";
+  readonly shutting_down: "shutting-down";
+  readonly stopped: "stopped";
+  readonly stopping: "stopping";
+  readonly terminated: "terminated";
+};
+export type InstanceStateName =
+  (typeof InstanceStateName)[keyof typeof InstanceStateName];
+export declare const InstanceBootModeValues: {
+  readonly legacy_bios: "legacy-bios";
+  readonly uefi: "uefi";
+};
+export type InstanceBootModeValues =
+  (typeof InstanceBootModeValues)[keyof typeof InstanceBootModeValues];
+export declare const InstanceLifecycleType: {
+  readonly capacity_block: "capacity-block";
+  readonly scheduled: "scheduled";
+  readonly spot: "spot";
+};
+export type InstanceLifecycleType =
+  (typeof InstanceLifecycleType)[keyof typeof InstanceLifecycleType];
+export declare const InstanceAutoRecoveryState: {
+  readonly default: "default";
+  readonly disabled: "disabled";
+};
+export type InstanceAutoRecoveryState =
+  (typeof InstanceAutoRecoveryState)[keyof typeof InstanceAutoRecoveryState];
+export declare const InstanceRebootMigrationState: {
+  readonly default: "default";
+  readonly disabled: "disabled";
+};
+export type InstanceRebootMigrationState =
+  (typeof InstanceRebootMigrationState)[keyof typeof InstanceRebootMigrationState];
+export declare const InstanceMetadataEndpointState: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+};
+export type InstanceMetadataEndpointState =
+  (typeof InstanceMetadataEndpointState)[keyof typeof InstanceMetadataEndpointState];
+export declare const InstanceMetadataProtocolState: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+};
+export type InstanceMetadataProtocolState =
+  (typeof InstanceMetadataProtocolState)[keyof typeof InstanceMetadataProtocolState];
+export declare const HttpTokensState: {
+  readonly optional: "optional";
+  readonly required: "required";
+};
+export type HttpTokensState =
+  (typeof HttpTokensState)[keyof typeof HttpTokensState];
+export declare const InstanceMetadataTagsState: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+};
+export type InstanceMetadataTagsState =
+  (typeof InstanceMetadataTagsState)[keyof typeof InstanceMetadataTagsState];
+export declare const InstanceMetadataOptionsState: {
+  readonly applied: "applied";
+  readonly pending: "pending";
+};
+export type InstanceMetadataOptionsState =
+  (typeof InstanceMetadataOptionsState)[keyof typeof InstanceMetadataOptionsState];
+export declare const MonitoringState: {
+  readonly disabled: "disabled";
+  readonly disabling: "disabling";
+  readonly enabled: "enabled";
+  readonly pending: "pending";
+};
+export type MonitoringState =
+  (typeof MonitoringState)[keyof typeof MonitoringState];
+export declare const HaStatus: {
+  readonly active: "active";
+  readonly invalid: "invalid";
+  readonly processing: "processing";
+  readonly standby: "standby";
+};
+export type HaStatus = (typeof HaStatus)[keyof typeof HaStatus];
+export declare const SqlServerLicenseUsage: {
+  readonly full: "full";
+  readonly waived: "waived";
+};
+export type SqlServerLicenseUsage =
+  (typeof SqlServerLicenseUsage)[keyof typeof SqlServerLicenseUsage];
+export declare const StatusName: {
+  readonly reachability: "reachability";
+};
+export type StatusName = (typeof StatusName)[keyof typeof StatusName];
+export declare const StatusType: {
+  readonly failed: "failed";
+  readonly initializing: "initializing";
+  readonly insufficient_data: "insufficient-data";
+  readonly passed: "passed";
+};
+export type StatusType = (typeof StatusType)[keyof typeof StatusType];
+export declare const SummaryStatus: {
+  readonly impaired: "impaired";
+  readonly initializing: "initializing";
+  readonly insufficient_data: "insufficient-data";
+  readonly not_applicable: "not-applicable";
+  readonly ok: "ok";
+};
+export type SummaryStatus = (typeof SummaryStatus)[keyof typeof SummaryStatus];
+export declare const EventCode: {
+  readonly instance_reboot: "instance-reboot";
+  readonly instance_retirement: "instance-retirement";
+  readonly instance_stop: "instance-stop";
+  readonly system_maintenance: "system-maintenance";
+  readonly system_reboot: "system-reboot";
+};
+export type EventCode = (typeof EventCode)[keyof typeof EventCode];
+export declare const LocationType: {
+  readonly availability_zone: "availability-zone";
+  readonly availability_zone_id: "availability-zone-id";
+  readonly outpost: "outpost";
+  readonly region: "region";
+};
+export type LocationType = (typeof LocationType)[keyof typeof LocationType];
+export declare const AttachmentLimitType: {
+  readonly DEDICATED: "dedicated";
+  readonly SHARED: "shared";
+};
+export type AttachmentLimitType =
+  (typeof AttachmentLimitType)[keyof typeof AttachmentLimitType];
+export declare const EbsOptimizedSupport: {
+  readonly default: "default";
+  readonly supported: "supported";
+  readonly unsupported: "unsupported";
+};
+export type EbsOptimizedSupport =
+  (typeof EbsOptimizedSupport)[keyof typeof EbsOptimizedSupport];
+export declare const EbsEncryptionSupport: {
+  readonly supported: "supported";
+  readonly unsupported: "unsupported";
+};
+export type EbsEncryptionSupport =
+  (typeof EbsEncryptionSupport)[keyof typeof EbsEncryptionSupport];
+export declare const EbsNvmeSupport: {
+  readonly REQUIRED: "required";
+  readonly SUPPORTED: "supported";
+  readonly UNSUPPORTED: "unsupported";
+};
+export type EbsNvmeSupport =
+  (typeof EbsNvmeSupport)[keyof typeof EbsNvmeSupport];
+export declare const InstanceTypeHypervisor: {
+  readonly NITRO: "nitro";
+  readonly XEN: "xen";
+};
+export type InstanceTypeHypervisor =
+  (typeof InstanceTypeHypervisor)[keyof typeof InstanceTypeHypervisor];
+export declare const DiskType: {
+  readonly hdd: "hdd";
+  readonly ssd: "ssd";
+};
+export type DiskType = (typeof DiskType)[keyof typeof DiskType];
+export declare const InstanceStorageEncryptionSupport: {
+  readonly required: "required";
+  readonly unsupported: "unsupported";
+};
+export type InstanceStorageEncryptionSupport =
+  (typeof InstanceStorageEncryptionSupport)[keyof typeof InstanceStorageEncryptionSupport];
+export declare const EphemeralNvmeSupport: {
+  readonly REQUIRED: "required";
+  readonly SUPPORTED: "supported";
+  readonly UNSUPPORTED: "unsupported";
+};
+export type EphemeralNvmeSupport =
+  (typeof EphemeralNvmeSupport)[keyof typeof EphemeralNvmeSupport];
+export declare const BandwidthWeightingType: {
+  readonly DEFAULT: "default";
+  readonly EBS_1: "ebs-1";
+  readonly VPC_1: "vpc-1";
+};
+export type BandwidthWeightingType =
+  (typeof BandwidthWeightingType)[keyof typeof BandwidthWeightingType];
+export declare const EnaSupport: {
+  readonly required: "required";
+  readonly supported: "supported";
+  readonly unsupported: "unsupported";
+};
+export type EnaSupport = (typeof EnaSupport)[keyof typeof EnaSupport];
+export declare const FlexibleEnaQueuesSupport: {
+  readonly SUPPORTED: "supported";
+  readonly UNSUPPORTED: "unsupported";
+};
+export type FlexibleEnaQueuesSupport =
+  (typeof FlexibleEnaQueuesSupport)[keyof typeof FlexibleEnaQueuesSupport];
+export declare const NitroEnclavesSupport: {
+  readonly SUPPORTED: "supported";
+  readonly UNSUPPORTED: "unsupported";
+};
+export type NitroEnclavesSupport =
+  (typeof NitroEnclavesSupport)[keyof typeof NitroEnclavesSupport];
+export declare const NitroTpmSupport: {
+  readonly SUPPORTED: "supported";
+  readonly UNSUPPORTED: "unsupported";
+};
+export type NitroTpmSupport =
+  (typeof NitroTpmSupport)[keyof typeof NitroTpmSupport];
+export declare const PhcSupport: {
+  readonly SUPPORTED: "supported";
+  readonly UNSUPPORTED: "unsupported";
+};
+export type PhcSupport = (typeof PhcSupport)[keyof typeof PhcSupport];
+export declare const PlacementGroupStrategy: {
+  readonly cluster: "cluster";
+  readonly partition: "partition";
+  readonly spread: "spread";
+};
+export type PlacementGroupStrategy =
+  (typeof PlacementGroupStrategy)[keyof typeof PlacementGroupStrategy];
+export declare const ArchitectureType: {
+  readonly arm64: "arm64";
+  readonly arm64_mac: "arm64_mac";
+  readonly i386: "i386";
+  readonly x86_64: "x86_64";
+  readonly x86_64_mac: "x86_64_mac";
+};
+export type ArchitectureType =
+  (typeof ArchitectureType)[keyof typeof ArchitectureType];
+export declare const SupportedAdditionalProcessorFeature: {
+  readonly AMD_SEV_SNP: "amd-sev-snp";
+};
+export type SupportedAdditionalProcessorFeature =
+  (typeof SupportedAdditionalProcessorFeature)[keyof typeof SupportedAdditionalProcessorFeature];
+export declare const RebootMigrationSupport: {
+  readonly SUPPORTED: "supported";
+  readonly UNSUPPORTED: "unsupported";
+};
+export type RebootMigrationSupport =
+  (typeof RebootMigrationSupport)[keyof typeof RebootMigrationSupport];
+export declare const BootModeType: {
+  readonly legacy_bios: "legacy-bios";
+  readonly uefi: "uefi";
+};
+export type BootModeType = (typeof BootModeType)[keyof typeof BootModeType];
+export declare const RootDeviceType: {
+  readonly ebs: "ebs";
+  readonly instance_store: "instance-store";
+};
+export type RootDeviceType =
+  (typeof RootDeviceType)[keyof typeof RootDeviceType];
+export declare const UsageClassType: {
+  readonly capacity_block: "capacity-block";
+  readonly on_demand: "on-demand";
+  readonly spot: "spot";
+};
+export type UsageClassType =
+  (typeof UsageClassType)[keyof typeof UsageClassType];
+export declare const LockState: {
+  readonly compliance: "compliance";
+  readonly compliance_cooloff: "compliance-cooloff";
+  readonly expired: "expired";
+  readonly governance: "governance";
+};
+export type LockState = (typeof LockState)[keyof typeof LockState];
+export declare const MoveStatus: {
+  readonly movingToVpc: "movingToVpc";
+  readonly restoringToClassic: "restoringToClassic";
+};
+export type MoveStatus = (typeof MoveStatus)[keyof typeof MoveStatus];
+export declare const FindingsFound: {
+  readonly false: "false";
+  readonly true: "true";
+  readonly unknown: "unknown";
+};
+export type FindingsFound = (typeof FindingsFound)[keyof typeof FindingsFound];
+export declare const AnalysisStatus: {
+  readonly failed: "failed";
+  readonly running: "running";
+  readonly succeeded: "succeeded";
+};
+export type AnalysisStatus =
+  (typeof AnalysisStatus)[keyof typeof AnalysisStatus];
+export declare const NetworkInterfaceAttribute: {
+  readonly associatePublicIpAddress: "associatePublicIpAddress";
+  readonly attachment: "attachment";
+  readonly description: "description";
+  readonly groupSet: "groupSet";
+  readonly sourceDestCheck: "sourceDestCheck";
+};
+export type NetworkInterfaceAttribute =
+  (typeof NetworkInterfaceAttribute)[keyof typeof NetworkInterfaceAttribute];
+export declare const OfferingClassType: {
+  readonly CONVERTIBLE: "convertible";
+  readonly STANDARD: "standard";
+};
+export type OfferingClassType =
+  (typeof OfferingClassType)[keyof typeof OfferingClassType];
+export declare const OfferingTypeValues: {
+  readonly All_Upfront: "All Upfront";
+  readonly Heavy_Utilization: "Heavy Utilization";
+  readonly Light_Utilization: "Light Utilization";
+  readonly Medium_Utilization: "Medium Utilization";
+  readonly No_Upfront: "No Upfront";
+  readonly Partial_Upfront: "Partial Upfront";
+};
+export type OfferingTypeValues =
+  (typeof OfferingTypeValues)[keyof typeof OfferingTypeValues];
+export declare const RIProductDescription: {
+  readonly Linux_UNIX: "Linux/UNIX";
+  readonly Linux_UNIX_Amazon_VPC_: "Linux/UNIX (Amazon VPC)";
+  readonly Windows: "Windows";
+  readonly Windows_Amazon_VPC_: "Windows (Amazon VPC)";
+};
+export type RIProductDescription =
+  (typeof RIProductDescription)[keyof typeof RIProductDescription];
+export declare const RecurringChargeFrequency: {
+  readonly Hourly: "Hourly";
+};
+export type RecurringChargeFrequency =
+  (typeof RecurringChargeFrequency)[keyof typeof RecurringChargeFrequency];
+export declare const Scope: {
+  readonly AVAILABILITY_ZONE: "Availability Zone";
+  readonly REGIONAL: "Region";
+};
+export type Scope = (typeof Scope)[keyof typeof Scope];
+export declare const ReservedInstanceState: {
+  readonly active: "active";
+  readonly payment_failed: "payment-failed";
+  readonly payment_pending: "payment-pending";
+  readonly queued: "queued";
+  readonly queued_deleted: "queued-deleted";
+  readonly retired: "retired";
+};
+export type ReservedInstanceState =
+  (typeof ReservedInstanceState)[keyof typeof ReservedInstanceState];
+export declare const ServiceLinkVirtualInterfaceConfigurationState: {
+  readonly available: "available";
+  readonly deleted: "deleted";
+  readonly deleting: "deleting";
+  readonly pending: "pending";
+};
+export type ServiceLinkVirtualInterfaceConfigurationState =
+  (typeof ServiceLinkVirtualInterfaceConfigurationState)[keyof typeof ServiceLinkVirtualInterfaceConfigurationState];
+export declare const SnapshotAttributeName: {
+  readonly createVolumePermission: "createVolumePermission";
+  readonly productCodes: "productCodes";
+};
+export type SnapshotAttributeName =
+  (typeof SnapshotAttributeName)[keyof typeof SnapshotAttributeName];
+export declare const TieringOperationStatus: {
+  readonly archival_completed: "archival-completed";
+  readonly archival_failed: "archival-failed";
+  readonly archival_in_progress: "archival-in-progress";
+  readonly permanent_restore_completed: "permanent-restore-completed";
+  readonly permanent_restore_failed: "permanent-restore-failed";
+  readonly permanent_restore_in_progress: "permanent-restore-in-progress";
+  readonly temporary_restore_completed: "temporary-restore-completed";
+  readonly temporary_restore_failed: "temporary-restore-failed";
+  readonly temporary_restore_in_progress: "temporary-restore-in-progress";
+};
+export type TieringOperationStatus =
+  (typeof TieringOperationStatus)[keyof typeof TieringOperationStatus];
+export declare const EventType: {
+  readonly BATCH_CHANGE: "fleetRequestChange";
+  readonly ERROR: "error";
+  readonly INFORMATION: "information";
+  readonly INSTANCE_CHANGE: "instanceChange";
+};
+export type EventType = (typeof EventType)[keyof typeof EventType];
+export declare const ExcessCapacityTerminationPolicy: {
+  readonly DEFAULT: "default";
+  readonly NO_TERMINATION: "noTermination";
+};
+export type ExcessCapacityTerminationPolicy =
+  (typeof ExcessCapacityTerminationPolicy)[keyof typeof ExcessCapacityTerminationPolicy];
+export declare const OnDemandAllocationStrategy: {
+  readonly LOWEST_PRICE: "lowestPrice";
+  readonly PRIORITIZED: "prioritized";
+};
+export type OnDemandAllocationStrategy =
+  (typeof OnDemandAllocationStrategy)[keyof typeof OnDemandAllocationStrategy];
+export declare const ReplacementStrategy: {
+  readonly LAUNCH: "launch";
+  readonly LAUNCH_BEFORE_TERMINATE: "launch-before-terminate";
+};
+export type ReplacementStrategy =
+  (typeof ReplacementStrategy)[keyof typeof ReplacementStrategy];
+export declare const SpotInstanceState: {
+  readonly active: "active";
+  readonly cancelled: "cancelled";
+  readonly closed: "closed";
+  readonly disabled: "disabled";
+  readonly failed: "failed";
+  readonly open: "open";
+};
+export type SpotInstanceState =
+  (typeof SpotInstanceState)[keyof typeof SpotInstanceState];
+export declare const VerifiedAccessLogDeliveryStatusCode: {
+  readonly FAILED: "failed";
+  readonly SUCCESS: "success";
+};
+export type VerifiedAccessLogDeliveryStatusCode =
+  (typeof VerifiedAccessLogDeliveryStatusCode)[keyof typeof VerifiedAccessLogDeliveryStatusCode];
+export declare const VolumeAttributeName: {
+  readonly autoEnableIO: "autoEnableIO";
+  readonly productCodes: "productCodes";
+};
+export type VolumeAttributeName =
+  (typeof VolumeAttributeName)[keyof typeof VolumeAttributeName];
+export declare const VolumeModificationState: {
+  readonly completed: "completed";
+  readonly failed: "failed";
+  readonly modifying: "modifying";
+  readonly optimizing: "optimizing";
+};
+export type VolumeModificationState =
+  (typeof VolumeModificationState)[keyof typeof VolumeModificationState];
+export declare const InitializationType: {
+  readonly default: "default";
+  readonly provisioned_rate: "provisioned-rate";
+  readonly volume_copy: "volume-copy";
+};
+export type InitializationType =
+  (typeof InitializationType)[keyof typeof InitializationType];
+export declare const VolumeStatusName: {
+  readonly initialization_state: "initialization-state";
+  readonly io_enabled: "io-enabled";
+  readonly io_performance: "io-performance";
+};
+export type VolumeStatusName =
+  (typeof VolumeStatusName)[keyof typeof VolumeStatusName];
+export declare const VolumeStatusInfoStatus: {
+  readonly impaired: "impaired";
+  readonly insufficient_data: "insufficient-data";
+  readonly ok: "ok";
+  readonly warning: "warning";
+};
+export type VolumeStatusInfoStatus =
+  (typeof VolumeStatusInfoStatus)[keyof typeof VolumeStatusInfoStatus];
+export declare const VpcAttributeName: {
+  readonly enableDnsHostnames: "enableDnsHostnames";
+  readonly enableDnsSupport: "enableDnsSupport";
+  readonly enableNetworkAddressUsageMetrics: "enableNetworkAddressUsageMetrics";
+};
+export type VpcAttributeName =
+  (typeof VpcAttributeName)[keyof typeof VpcAttributeName];
+export declare const VpcBlockPublicAccessExclusionsAllowed: {
+  readonly allowed: "allowed";
+  readonly not_allowed: "not-allowed";
+};
+export type VpcBlockPublicAccessExclusionsAllowed =
+  (typeof VpcBlockPublicAccessExclusionsAllowed)[keyof typeof VpcBlockPublicAccessExclusionsAllowed];
+export declare const InternetGatewayBlockMode: {
+  readonly block_bidirectional: "block-bidirectional";
+  readonly block_ingress: "block-ingress";
+  readonly off: "off";
+};
+export type InternetGatewayBlockMode =
+  (typeof InternetGatewayBlockMode)[keyof typeof InternetGatewayBlockMode];
+export declare const ManagedBy: {
+  readonly account: "account";
+  readonly declarative_policy: "declarative-policy";
+};
+export type ManagedBy = (typeof ManagedBy)[keyof typeof ManagedBy];
+export declare const VpcBlockPublicAccessState: {
+  readonly default_state: "default-state";
+  readonly update_complete: "update-complete";
+  readonly update_in_progress: "update-in-progress";
+};
+export type VpcBlockPublicAccessState =
+  (typeof VpcBlockPublicAccessState)[keyof typeof VpcBlockPublicAccessState];
+export declare const CapacityManagerStatus: {
+  readonly DISABLED: "disabled";
+  readonly ENABLED: "enabled";
+};
+export type CapacityManagerStatus =
+  (typeof CapacityManagerStatus)[keyof typeof CapacityManagerStatus];
+export declare const ImageBlockPublicAccessDisabledState: {
+  readonly unblocked: "unblocked";
+};
+export type ImageBlockPublicAccessDisabledState =
+  (typeof ImageBlockPublicAccessDisabledState)[keyof typeof ImageBlockPublicAccessDisabledState];
+export declare const RouteServerPropagationState: {
+  readonly AVAILABLE: "available";
+  readonly DELETING: "deleting";
+  readonly PENDING: "pending";
+};
+export type RouteServerPropagationState =
+  (typeof RouteServerPropagationState)[keyof typeof RouteServerPropagationState];
+export declare const SnapshotBlockPublicAccessState: {
+  readonly block_all_sharing: "block-all-sharing";
+  readonly block_new_sharing: "block-new-sharing";
+  readonly unblocked: "unblocked";
+};
+export type SnapshotBlockPublicAccessState =
+  (typeof SnapshotBlockPublicAccessState)[keyof typeof SnapshotBlockPublicAccessState];
+export declare const TransitGatewayPropagationState: {
+  readonly disabled: "disabled";
+  readonly disabling: "disabling";
+  readonly enabled: "enabled";
+  readonly enabling: "enabling";
+};
+export type TransitGatewayPropagationState =
+  (typeof TransitGatewayPropagationState)[keyof typeof TransitGatewayPropagationState];
+export declare const ImageBlockPublicAccessEnabledState: {
+  readonly block_new_sharing: "block-new-sharing";
+};
+export type ImageBlockPublicAccessEnabledState =
+  (typeof ImageBlockPublicAccessEnabledState)[keyof typeof ImageBlockPublicAccessEnabledState];
+export declare const ClientCertificateRevocationListStatusCode: {
+  readonly active: "active";
+  readonly pending: "pending";
+};
+export type ClientCertificateRevocationListStatusCode =
+  (typeof ClientCertificateRevocationListStatusCode)[keyof typeof ClientCertificateRevocationListStatusCode];
+export declare const IngestionStatus: {
+  readonly INGESTION_COMPLETE: "ingestion-complete";
+  readonly INGESTION_FAILED: "ingestion-failed";
+  readonly INITIAL_INGESTION_IN_PROGRESS: "initial-ingestion-in-progress";
+};
+export type IngestionStatus =
+  (typeof IngestionStatus)[keyof typeof IngestionStatus];
+export declare const Comparison: {
+  readonly EQUALS: "equals";
+  readonly IN: "in";
+};
+export type Comparison = (typeof Comparison)[keyof typeof Comparison];
+export declare const FilterByDimension: {
+  readonly ACCOUNT_ID: "account-id";
+  readonly AVAILABILITY_ZONE_ID: "availability-zone-id";
+  readonly INSTANCE_FAMILY: "instance-family";
+  readonly INSTANCE_PLATFORM: "instance-platform";
+  readonly INSTANCE_TYPE: "instance-type";
+  readonly RESERVATION_ARN: "reservation-arn";
+  readonly RESERVATION_CREATE_TIMESTAMP: "reservation-create-timestamp";
+  readonly RESERVATION_END_DATE_TYPE: "reservation-end-date-type";
+  readonly RESERVATION_END_TIMESTAMP: "reservation-end-timestamp";
+  readonly RESERVATION_ID: "reservation-id";
+  readonly RESERVATION_INSTANCE_MATCH_CRITERIA: "reservation-instance-match-criteria";
+  readonly RESERVATION_START_TIMESTAMP: "reservation-start-timestamp";
+  readonly RESERVATION_STATE: "reservation-state";
+  readonly RESERVATION_TYPE: "reservation-type";
+  readonly RESERVATION_UNUSED_FINANCIAL_OWNER: "reservation-unused-financial-owner";
+  readonly RESOURCE_REGION: "resource-region";
+  readonly TENANCY: "tenancy";
+};
+export type FilterByDimension =
+  (typeof FilterByDimension)[keyof typeof FilterByDimension];
+export declare const GroupBy: {
+  readonly ACCOUNT_ID: "account-id";
+  readonly AVAILABILITY_ZONE_ID: "availability-zone-id";
+  readonly INSTANCE_FAMILY: "instance-family";
+  readonly INSTANCE_PLATFORM: "instance-platform";
+  readonly INSTANCE_TYPE: "instance-type";
+  readonly RESERVATION_ARN: "reservation-arn";
+  readonly RESERVATION_CREATE_TIMESTAMP: "reservation-create-timestamp";
+  readonly RESERVATION_END_DATE_TYPE: "reservation-end-date-type";
+  readonly RESERVATION_END_TIMESTAMP: "reservation-end-timestamp";
+  readonly RESERVATION_ID: "reservation-id";
+  readonly RESERVATION_INSTANCE_MATCH_CRITERIA: "reservation-instance-match-criteria";
+  readonly RESERVATION_START_TIMESTAMP: "reservation-start-timestamp";
+  readonly RESERVATION_STATE: "reservation-state";
+  readonly RESERVATION_TYPE: "reservation-type";
+  readonly RESERVATION_UNUSED_FINANCIAL_OWNER: "reservation-unused-financial-owner";
+  readonly RESOURCE_REGION: "resource-region";
+  readonly TENANCY: "tenancy";
+};
+export type GroupBy = (typeof GroupBy)[keyof typeof GroupBy];
+export declare const Metric: {
+  readonly RESERVATION_AVG_COMMITTED_SIZE_INST: "reservation-avg-committed-size-inst";
+  readonly RESERVATION_AVG_COMMITTED_SIZE_VCPU: "reservation-avg-committed-size-vcpu";
+  readonly RESERVATION_AVG_FUTURE_SIZE_INST: "reservation-avg-future-size-inst";
+  readonly RESERVATION_AVG_FUTURE_SIZE_VCPU: "reservation-avg-future-size-vcpu";
+  readonly RESERVATION_AVG_UTILIZATION_INST: "reservation-avg-utilization-inst";
+  readonly RESERVATION_AVG_UTILIZATION_VCPU: "reservation-avg-utilization-vcpu";
+  readonly RESERVATION_MAX_COMMITTED_SIZE_INST: "reservation-max-committed-size-inst";
+  readonly RESERVATION_MAX_COMMITTED_SIZE_VCPU: "reservation-max-committed-size-vcpu";
+  readonly RESERVATION_MAX_FUTURE_SIZE_INST: "reservation-max-future-size-inst";
+  readonly RESERVATION_MAX_FUTURE_SIZE_VCPU: "reservation-max-future-size-vcpu";
+  readonly RESERVATION_MAX_SIZE_INST: "reservation-max-size-inst";
+  readonly RESERVATION_MAX_SIZE_VCPU: "reservation-max-size-vcpu";
+  readonly RESERVATION_MAX_UNUSED_SIZE_INST: "reservation-max-unused-size-inst";
+  readonly RESERVATION_MAX_UNUSED_SIZE_VCPU: "reservation-max-unused-size-vcpu";
+  readonly RESERVATION_MAX_UTILIZATION: "reservation-max-utilization";
+  readonly RESERVATION_MIN_COMMITTED_SIZE_INST: "reservation-min-committed-size-inst";
+  readonly RESERVATION_MIN_COMMITTED_SIZE_VCPU: "reservation-min-committed-size-vcpu";
+  readonly RESERVATION_MIN_FUTURE_SIZE_INST: "reservation-min-future-size-inst";
+  readonly RESERVATION_MIN_FUTURE_SIZE_VCPU: "reservation-min-future-size-vcpu";
+  readonly RESERVATION_MIN_SIZE_INST: "reservation-min-size-inst";
+  readonly RESERVATION_MIN_SIZE_VCPU: "reservation-min-size-vcpu";
+  readonly RESERVATION_MIN_UNUSED_SIZE_INST: "reservation-min-unused-size-inst";
+  readonly RESERVATION_MIN_UNUSED_SIZE_VCPU: "reservation-min-unused-size-vcpu";
+  readonly RESERVATION_MIN_UTILIZATION: "reservation-min-utilization";
+  readonly RESERVATION_TOTAL_CAPACITY_HRS_INST: "reservation-total-capacity-hrs-inst";
+  readonly RESERVATION_TOTAL_CAPACITY_HRS_VCPU: "reservation-total-capacity-hrs-vcpu";
+  readonly RESERVATION_TOTAL_COUNT: "reservation-total-count";
+  readonly RESERVATION_TOTAL_ESTIMATED_COST: "reservation-total-estimated-cost";
+  readonly RESERVATION_UNUSED_TOTAL_CAPACITY_HRS_INST: "reservation-unused-total-capacity-hrs-inst";
+  readonly RESERVATION_UNUSED_TOTAL_CAPACITY_HRS_VCPU: "reservation-unused-total-capacity-hrs-vcpu";
+  readonly RESERVATION_UNUSED_TOTAL_ESTIMATED_COST: "reservation-unused-total-estimated-cost";
+  readonly RESERVED_TOTAL_ESTIMATED_COST: "reserved-total-estimated-cost";
+  readonly RESERVED_TOTAL_USAGE_HRS_INST: "reserved-total-usage-hrs-inst";
+  readonly RESERVED_TOTAL_USAGE_HRS_VCPU: "reserved-total-usage-hrs-vcpu";
+  readonly SPOT_AVG_RUN_TIME_BEFORE_INTERRUPTION_INST: "spot-avg-run-time-before-interruption-inst";
+  readonly SPOT_MAX_RUN_TIME_BEFORE_INTERRUPTION_INST: "spot-max-run-time-before-interruption-inst";
+  readonly SPOT_MIN_RUN_TIME_BEFORE_INTERRUPTION_INST: "spot-min-run-time-before-interruption-inst";
+  readonly SPOT_TOTAL_ESTIMATED_COST: "spot-total-estimated-cost";
+  readonly SPOT_TOTAL_USAGE_HRS_INST: "spot-total-usage-hrs-inst";
+  readonly SPOT_TOTAL_USAGE_HRS_VCPU: "spot-total-usage-hrs-vcpu";
+  readonly UNRESERVED_TOTAL_ESTIMATED_COST: "unreserved-total-estimated-cost";
+  readonly UNRESERVED_TOTAL_USAGE_HRS_INST: "unreserved-total-usage-hrs-inst";
+  readonly UNRESERVED_TOTAL_USAGE_HRS_VCPU: "unreserved-total-usage-hrs-vcpu";
+};
+export type Metric = (typeof Metric)[keyof typeof Metric];
+export declare const ReservationEndDateType: {
+  readonly LIMITED: "limited";
+  readonly UNLIMITED: "unlimited";
+};
+export type ReservationEndDateType =
+  (typeof ReservationEndDateType)[keyof typeof ReservationEndDateType];
+export declare const ReservationType: {
+  readonly CAPACITY_BLOCK: "capacity-block";
+  readonly ODCR: "odcr";
+};
+export type ReservationType =
+  (typeof ReservationType)[keyof typeof ReservationType];
+export declare const CapacityTenancy: {
+  readonly DEDICATED: "dedicated";
+  readonly DEFAULT: "default";
+};
+export type CapacityTenancy =
+  (typeof CapacityTenancy)[keyof typeof CapacityTenancy];
+export declare const UnlimitedSupportedInstanceFamily: {
+  readonly t2: "t2";
+  readonly t3: "t3";
+  readonly t3a: "t3a";
+  readonly t4g: "t4g";
+};
+export type UnlimitedSupportedInstanceFamily =
+  (typeof UnlimitedSupportedInstanceFamily)[keyof typeof UnlimitedSupportedInstanceFamily];
+export declare const IpamPolicyManagedBy: {
+  readonly account: "account";
+  readonly delegated_administrator_for_ipam: "delegated-administrator-for-ipam";
+};
+export type IpamPolicyManagedBy =
+  (typeof IpamPolicyManagedBy)[keyof typeof IpamPolicyManagedBy];
+export declare const PartitionLoadFrequency: {
+  readonly DAILY: "daily";
+  readonly MONTHLY: "monthly";
+  readonly NONE: "none";
+  readonly WEEKLY: "weekly";
+};
+export type PartitionLoadFrequency =
+  (typeof PartitionLoadFrequency)[keyof typeof PartitionLoadFrequency];
+export declare const EkPubKeyFormat: {
+  readonly der: "der";
+  readonly tpmt: "tpmt";
+};
+export type EkPubKeyFormat =
+  (typeof EkPubKeyFormat)[keyof typeof EkPubKeyFormat];
+export declare const EkPubKeyType: {
+  readonly ECC_SEC_P384: "ecc-sec-p384";
+  readonly RSA_2048: "rsa-2048";
+};
+export type EkPubKeyType = (typeof EkPubKeyType)[keyof typeof EkPubKeyType];
+export declare const IpamComplianceStatus: {
+  readonly compliant: "compliant";
+  readonly ignored: "ignored";
+  readonly noncompliant: "noncompliant";
+  readonly unmanaged: "unmanaged";
+};
+export type IpamComplianceStatus =
+  (typeof IpamComplianceStatus)[keyof typeof IpamComplianceStatus];
+export declare const IpamOverlapStatus: {
+  readonly ignored: "ignored";
+  readonly nonoverlapping: "nonoverlapping";
+  readonly overlapping: "overlapping";
+};
+export type IpamOverlapStatus =
+  (typeof IpamOverlapStatus)[keyof typeof IpamOverlapStatus];
+export declare const IpamAddressHistoryResourceType: {
+  readonly eip: "eip";
+  readonly instance: "instance";
+  readonly network_interface: "network-interface";
+  readonly subnet: "subnet";
+  readonly vpc: "vpc";
+};
+export type IpamAddressHistoryResourceType =
+  (typeof IpamAddressHistoryResourceType)[keyof typeof IpamAddressHistoryResourceType];
+export declare const IpamDiscoveryFailureCode: {
+  readonly assume_role_failure: "assume-role-failure";
+  readonly throttling_failure: "throttling-failure";
+  readonly unauthorized_failure: "unauthorized-failure";
+};
+export type IpamDiscoveryFailureCode =
+  (typeof IpamDiscoveryFailureCode)[keyof typeof IpamDiscoveryFailureCode];
+export declare const IpamPublicAddressType: {
+  readonly AMAZON_OWNED_CONTIG: "amazon-owned-contig";
+  readonly AMAZON_OWNED_EIP: "amazon-owned-eip";
+  readonly BYOIP: "byoip";
+  readonly EC2_PUBLIC_IP: "ec2-public-ip";
+  readonly SERVICE_MANAGED_BYOIP: "service-managed-byoip";
+  readonly SERVICE_MANAGED_IP: "service-managed-ip";
+};
+export type IpamPublicAddressType =
+  (typeof IpamPublicAddressType)[keyof typeof IpamPublicAddressType];
+export declare const IpamPublicAddressAssociationStatus: {
+  readonly ASSOCIATED: "associated";
+  readonly DISASSOCIATED: "disassociated";
+};
+export type IpamPublicAddressAssociationStatus =
+  (typeof IpamPublicAddressAssociationStatus)[keyof typeof IpamPublicAddressAssociationStatus];
+export declare const IpamPublicAddressAwsService: {
+  readonly AGA: "global-accelerator";
+  readonly DMS: "database-migration-service";
+  readonly EC2_LB: "load-balancer";
+  readonly ECS: "elastic-container-service";
+  readonly NAT_GATEWAY: "nat-gateway";
+  readonly OTHER: "other";
+  readonly RDS: "relational-database-service";
+  readonly REDSHIFT: "redshift";
+  readonly S2S_VPN: "site-to-site-vpn";
+};
+export type IpamPublicAddressAwsService =
+  (typeof IpamPublicAddressAwsService)[keyof typeof IpamPublicAddressAwsService];
+export declare const IpamResourceCidrIpSource: {
+  readonly amazon: "amazon";
+  readonly byoip: "byoip";
+  readonly none: "none";
+};
+export type IpamResourceCidrIpSource =
+  (typeof IpamResourceCidrIpSource)[keyof typeof IpamResourceCidrIpSource];
+export declare const IpamNetworkInterfaceAttachmentStatus: {
+  readonly available: "available";
+  readonly in_use: "in-use";
+};
+export type IpamNetworkInterfaceAttachmentStatus =
+  (typeof IpamNetworkInterfaceAttachmentStatus)[keyof typeof IpamNetworkInterfaceAttachmentStatus];
+export declare const IpamPolicyResourceType: {
+  readonly alb: "alb";
+  readonly eip: "eip";
+  readonly rds: "rds";
+  readonly rnat: "rnat";
+};
+export type IpamPolicyResourceType =
+  (typeof IpamPolicyResourceType)[keyof typeof IpamPolicyResourceType];
+export declare const IpamManagementState: {
+  readonly ignored: "ignored";
+  readonly managed: "managed";
+  readonly unmanaged: "unmanaged";
+};
+export type IpamManagementState =
+  (typeof IpamManagementState)[keyof typeof IpamManagementState];
+export declare const RouteServerRouteInstallationStatus: {
+  readonly INSTALLED: "installed";
+  readonly REJECTED: "rejected";
+};
+export type RouteServerRouteInstallationStatus =
+  (typeof RouteServerRouteInstallationStatus)[keyof typeof RouteServerRouteInstallationStatus];
+export declare const RouteServerRouteStatus: {
+  readonly IN_FIB: "in-fib";
+  readonly IN_RIB: "in-rib";
+};
+export type RouteServerRouteStatus =
+  (typeof RouteServerRouteStatus)[keyof typeof RouteServerRouteStatus];
+export declare const LockMode: {
+  readonly compliance: "compliance";
+  readonly governance: "governance";
+};
+export type LockMode = (typeof LockMode)[keyof typeof LockMode];
+export declare const ModifyAvailabilityZoneOptInStatus: {
+  readonly not_opted_in: "not-opted-in";
+  readonly opted_in: "opted-in";
+};
+export type ModifyAvailabilityZoneOptInStatus =
+  (typeof ModifyAvailabilityZoneOptInStatus)[keyof typeof ModifyAvailabilityZoneOptInStatus];
+export declare const OperationType: {
+  readonly add: "add";
+  readonly remove: "remove";
+};
+export type OperationType = (typeof OperationType)[keyof typeof OperationType];
+export declare const UnsuccessfulInstanceCreditSpecificationErrorCode: {
+  readonly INCORRECT_INSTANCE_STATE: "IncorrectInstanceState";
+  readonly INSTANCE_CREDIT_SPECIFICATION_NOT_SUPPORTED: "InstanceCreditSpecification.NotSupported";
+  readonly INSTANCE_NOT_FOUND: "InvalidInstanceID.NotFound";
+  readonly INVALID_INSTANCE_ID: "InvalidInstanceID.Malformed";
+};
+export type UnsuccessfulInstanceCreditSpecificationErrorCode =
+  (typeof UnsuccessfulInstanceCreditSpecificationErrorCode)[keyof typeof UnsuccessfulInstanceCreditSpecificationErrorCode];
+export declare const DefaultInstanceMetadataEndpointState: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+  readonly no_preference: "no-preference";
+};
+export type DefaultInstanceMetadataEndpointState =
+  (typeof DefaultInstanceMetadataEndpointState)[keyof typeof DefaultInstanceMetadataEndpointState];
+export declare const MetadataDefaultHttpTokensState: {
+  readonly no_preference: "no-preference";
+  readonly optional: "optional";
+  readonly required: "required";
+};
+export type MetadataDefaultHttpTokensState =
+  (typeof MetadataDefaultHttpTokensState)[keyof typeof MetadataDefaultHttpTokensState];
+export declare const DefaultInstanceMetadataTagsState: {
+  readonly disabled: "disabled";
+  readonly enabled: "enabled";
+  readonly no_preference: "no-preference";
+};
+export type DefaultInstanceMetadataTagsState =
+  (typeof DefaultInstanceMetadataTagsState)[keyof typeof DefaultInstanceMetadataTagsState];
+export declare const HostTenancy: {
+  readonly dedicated: "dedicated";
+  readonly default: "default";
+  readonly host: "host";
+};
+export type HostTenancy = (typeof HostTenancy)[keyof typeof HostTenancy];
+export declare const PublicIpDnsOption: {
+  readonly public_dual_stack_dns_name: "public-dual-stack-dns-name";
+  readonly public_ipv4_dns_name: "public-ipv4-dns-name";
+  readonly public_ipv6_dns_name: "public-ipv6-dns-name";
+};
+export type PublicIpDnsOption =
+  (typeof PublicIpDnsOption)[keyof typeof PublicIpDnsOption];
+export declare const TargetStorageTier: {
+  readonly archive: "archive";
+};
+export type TargetStorageTier =
+  (typeof TargetStorageTier)[keyof typeof TargetStorageTier];
+export declare const TrafficMirrorFilterRuleField: {
+  readonly description: "description";
+  readonly destination_port_range: "destination-port-range";
+  readonly protocol: "protocol";
+  readonly source_port_range: "source-port-range";
+};
+export type TrafficMirrorFilterRuleField =
+  (typeof TrafficMirrorFilterRuleField)[keyof typeof TrafficMirrorFilterRuleField];
+export declare const TrafficMirrorSessionField: {
+  readonly description: "description";
+  readonly packet_length: "packet-length";
+  readonly virtual_network_id: "virtual-network-id";
+};
+export type TrafficMirrorSessionField =
+  (typeof TrafficMirrorSessionField)[keyof typeof TrafficMirrorSessionField];
+export declare const VpcTenancy: {
+  readonly default: "default";
+};
+export type VpcTenancy = (typeof VpcTenancy)[keyof typeof VpcTenancy];
+export declare const Status: {
+  readonly inClassic: "InClassic";
+  readonly inVpc: "InVpc";
+  readonly moveInProgress: "MoveInProgress";
+};
+export type Status = (typeof Status)[keyof typeof Status];
+export declare const VerificationMethod: {
+  readonly dns_token: "dns-token";
+  readonly remarks_x509: "remarks-x509";
+};
+export type VerificationMethod =
+  (typeof VerificationMethod)[keyof typeof VerificationMethod];
+export declare const ReportInstanceReasonCodes: {
+  readonly instance_stuck_in_state: "instance-stuck-in-state";
+  readonly not_accepting_credentials: "not-accepting-credentials";
+  readonly other: "other";
+  readonly password_not_available: "password-not-available";
+  readonly performance_ebs_volume: "performance-ebs-volume";
+  readonly performance_instance_store: "performance-instance-store";
+  readonly performance_network: "performance-network";
+  readonly performance_other: "performance-other";
+  readonly unresponsive: "unresponsive";
+};
+export type ReportInstanceReasonCodes =
+  (typeof ReportInstanceReasonCodes)[keyof typeof ReportInstanceReasonCodes];
+export declare const ReportStatusType: {
+  readonly impaired: "impaired";
+  readonly ok: "ok";
+};
+export type ReportStatusType =
+  (typeof ReportStatusType)[keyof typeof ReportStatusType];
+export declare const ResetFpgaImageAttributeName: {
+  readonly loadPermission: "loadPermission";
+};
+export type ResetFpgaImageAttributeName =
+  (typeof ResetFpgaImageAttributeName)[keyof typeof ResetFpgaImageAttributeName];
+export declare const ResetImageAttributeName: {
+  readonly launchPermission: "launchPermission";
+};
+export type ResetImageAttributeName =
+  (typeof ResetImageAttributeName)[keyof typeof ResetImageAttributeName];
+export declare const MembershipType: {
+  readonly igmp: "igmp";
+  readonly static: "static";
+};
+export type MembershipType =
+  (typeof MembershipType)[keyof typeof MembershipType];