@aws-sdk/client-ec2 3.301.0 → 3.303.0

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

@@ -110,15 +110,17 @@ export interface RouteTableAssociation {
 export interface PropagatingVgw {
   GatewayId?: string;
 }
-export declare enum RouteOrigin {
-  CreateRoute = "CreateRoute",
-  CreateRouteTable = "CreateRouteTable",
-  EnableVgwRoutePropagation = "EnableVgwRoutePropagation",
-}
-export declare enum RouteState {
-  active = "active",
-  blackhole = "blackhole",
-}
+export declare const RouteOrigin: {
+  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";
+};
+export type RouteState = (typeof RouteState)[keyof typeof RouteState];
 export interface Route {
   DestinationCidrBlock?: string;
   DestinationIpv6CidrBlock?: string;
@@ -167,17 +169,19 @@ export interface CreateSnapshotRequest {
   TagSpecifications?: TagSpecification[];
   DryRun?: boolean;
 }
-export declare enum SnapshotState {
-  completed = "completed",
-  error = "error",
-  pending = "pending",
-  recoverable = "recoverable",
-  recovering = "recovering",
-}
-export declare enum StorageTier {
-  archive = "archive",
-  standard = "standard",
-}
+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 interface Snapshot {
   DataEncryptionKeyId?: string;
   Description?: string;
@@ -197,9 +201,11 @@ export interface Snapshot {
   StorageTier?: StorageTier | string;
   RestoreExpiryTime?: Date;
 }
-export declare enum CopyTagsFromSource {
-  volume = "volume",
-}
+export declare const CopyTagsFromSource: {
+  readonly volume: "volume";
+};
+export type CopyTagsFromSource =
+  (typeof CopyTagsFromSource)[keyof typeof CopyTagsFromSource];
 export interface InstanceSpecification {
   InstanceId: string | undefined;
   ExcludeBootVolume?: boolean;
@@ -238,10 +244,12 @@ export interface SpotInstanceStateFault {
   Code?: string;
   Message?: string;
 }
-export declare enum DatafeedSubscriptionState {
-  Active = "Active",
-  Inactive = "Inactive",
-}
+export declare const DatafeedSubscriptionState: {
+  readonly Active: "Active";
+  readonly Inactive: "Inactive";
+};
+export type DatafeedSubscriptionState =
+  (typeof DatafeedSubscriptionState)[keyof typeof DatafeedSubscriptionState];
 export interface SpotDatafeedSubscription {
   Bucket?: string;
   Fault?: SpotInstanceStateFault;
@@ -279,10 +287,12 @@ export interface CreateSubnetRequest {
 export interface CreateSubnetResult {
   Subnet?: Subnet;
 }
-export declare enum SubnetCidrReservationType {
-  explicit = "explicit",
-  prefix = "prefix",
-}
+export declare const SubnetCidrReservationType: {
+  readonly explicit: "explicit";
+  readonly prefix: "prefix";
+};
+export type SubnetCidrReservationType =
+  (typeof SubnetCidrReservationType)[keyof typeof SubnetCidrReservationType];
 export interface CreateSubnetCidrReservationRequest {
   SubnetId: string | undefined;
   Cidr: string | undefined;
@@ -318,14 +328,18 @@ export interface TrafficMirrorPortRange {
   FromPort?: number;
   ToPort?: number;
 }
-export declare enum TrafficMirrorRuleAction {
-  accept = "accept",
-  reject = "reject",
-}
-export declare enum TrafficDirection {
-  egress = "egress",
-  ingress = "ingress",
-}
+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 interface TrafficMirrorFilterRule {
   TrafficMirrorFilterRuleId?: string;
   TrafficMirrorFilterId?: string;
@@ -339,9 +353,11 @@ export interface TrafficMirrorFilterRule {
   SourceCidrBlock?: string;
   Description?: string;
 }
-export declare enum TrafficMirrorNetworkService {
-  amazon_dns = "amazon-dns",
-}
+export declare const TrafficMirrorNetworkService: {
+  readonly amazon_dns: "amazon-dns";
+};
+export type TrafficMirrorNetworkService =
+  (typeof TrafficMirrorNetworkService)[keyof typeof TrafficMirrorNetworkService];
 export interface TrafficMirrorFilter {
   TrafficMirrorFilterId?: string;
   IngressFilterRules?: TrafficMirrorFilterRule[];
@@ -413,11 +429,13 @@ export interface CreateTrafficMirrorTargetRequest {
   ClientToken?: string;
   GatewayLoadBalancerEndpointId?: string;
 }
-export declare enum TrafficMirrorTargetType {
-  gateway_load_balancer_endpoint = "gateway-load-balancer-endpoint",
-  network_interface = "network-interface",
-  network_load_balancer = "network-load-balancer",
-}
+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 interface TrafficMirrorTarget {
   TrafficMirrorTargetId?: string;
   NetworkInterfaceId?: string;
@@ -432,26 +450,36 @@ export interface CreateTrafficMirrorTargetResult {
   TrafficMirrorTarget?: TrafficMirrorTarget;
   ClientToken?: string;
 }
-export declare enum AutoAcceptSharedAttachmentsValue {
-  disable = "disable",
-  enable = "enable",
-}
-export declare enum DefaultRouteTableAssociationValue {
-  disable = "disable",
-  enable = "enable",
-}
-export declare enum DefaultRouteTablePropagationValue {
-  disable = "disable",
-  enable = "enable",
-}
-export declare enum MulticastSupportValue {
-  disable = "disable",
-  enable = "enable",
-}
-export declare enum VpnEcmpSupportValue {
-  disable = "disable",
-  enable = "enable",
-}
+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 interface TransitGatewayRequestOptions {
   AmazonSideAsn?: number;
   AutoAcceptSharedAttachments?: AutoAcceptSharedAttachmentsValue | string;
@@ -480,13 +508,15 @@ export interface TransitGatewayOptions {
   DnsSupport?: DnsSupportValue | string;
   MulticastSupport?: MulticastSupportValue | string;
 }
-export declare enum TransitGatewayState {
-  available = "available",
-  deleted = "deleted",
-  deleting = "deleting",
-  modifying = "modifying",
-  pending = "pending",
-}
+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 interface TransitGateway {
   TransitGatewayId?: string;
   TransitGatewayArn?: string;
@@ -500,9 +530,10 @@ export interface TransitGateway {
 export interface CreateTransitGatewayResult {
   TransitGateway?: TransitGateway;
 }
-export declare enum ProtocolValue {
-  gre = "gre",
-}
+export declare const ProtocolValue: {
+  readonly gre: "gre";
+};
+export type ProtocolValue = (typeof ProtocolValue)[keyof typeof ProtocolValue];
 export interface CreateTransitGatewayConnectRequestOptions {
   Protocol: ProtocolValue | string | undefined;
 }
@@ -539,10 +570,11 @@ export interface CreateTransitGatewayConnectPeerRequest {
   TagSpecifications?: TagSpecification[];
   DryRun?: boolean;
 }
-export declare enum BgpStatus {
-  down = "down",
-  up = "up",
-}
+export declare const BgpStatus: {
+  readonly down: "down";
+  readonly up: "up";
+};
+export type BgpStatus = (typeof BgpStatus)[keyof typeof BgpStatus];
 export interface TransitGatewayAttachmentBgpConfiguration {
   TransitGatewayAsn?: number;
   PeerAsn?: number;
@@ -557,12 +589,14 @@ export interface TransitGatewayConnectPeerConfiguration {
   Protocol?: ProtocolValue | string;
   BgpConfigurations?: TransitGatewayAttachmentBgpConfiguration[];
 }
-export declare enum TransitGatewayConnectPeerState {
-  available = "available",
-  deleted = "deleted",
-  deleting = "deleting",
-  pending = "pending",
-}
+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 interface TransitGatewayConnectPeer {
   TransitGatewayAttachmentId?: string;
   TransitGatewayConnectPeerId?: string;
@@ -574,18 +608,24 @@ export interface TransitGatewayConnectPeer {
 export interface CreateTransitGatewayConnectPeerResult {
   TransitGatewayConnectPeer?: TransitGatewayConnectPeer;
 }
-export declare enum AutoAcceptSharedAssociationsValue {
-  disable = "disable",
-  enable = "enable",
-}
-export declare enum Igmpv2SupportValue {
-  disable = "disable",
-  enable = "enable",
-}
-export declare enum StaticSourcesSupportValue {
-  disable = "disable",
-  enable = "enable",
-}
+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 interface CreateTransitGatewayMulticastDomainRequestOptions {
   Igmpv2Support?: Igmpv2SupportValue | string;
   StaticSourcesSupport?: StaticSourcesSupportValue | string;
@@ -602,12 +642,14 @@ export interface TransitGatewayMulticastDomainOptions {
   StaticSourcesSupport?: StaticSourcesSupportValue | string;
   AutoAcceptSharedAssociations?: AutoAcceptSharedAssociationsValue | string;
 }
-export declare enum TransitGatewayMulticastDomainState {
-  available = "available",
-  deleted = "deleted",
-  deleting = "deleting",
-  pending = "pending",
-}
+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 interface TransitGatewayMulticastDomain {
   TransitGatewayMulticastDomainId?: string;
   TransitGatewayId?: string;
@@ -641,12 +683,14 @@ export interface CreateTransitGatewayPolicyTableRequest {
   TagSpecifications?: TagSpecification[];
   DryRun?: boolean;
 }
-export declare enum TransitGatewayPolicyTableState {
-  available = "available",
-  deleted = "deleted",
-  deleting = "deleting",
-  pending = "pending",
-}
+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 interface TransitGatewayPolicyTable {
   TransitGatewayPolicyTableId?: string;
   TransitGatewayId?: string;
@@ -664,12 +708,14 @@ export interface CreateTransitGatewayPrefixListReferenceRequest {
   Blackhole?: boolean;
   DryRun?: boolean;
 }
-export declare enum TransitGatewayPrefixListReferenceState {
-  available = "available",
-  deleting = "deleting",
-  modifying = "modifying",
-  pending = "pending",
-}
+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 interface TransitGatewayPrefixListAttachment {
   TransitGatewayAttachmentId?: string;
   ResourceType?: TransitGatewayAttachmentResourceType | string;
@@ -693,22 +739,26 @@ export interface CreateTransitGatewayRouteRequest {
   Blackhole?: boolean;
   DryRun?: boolean;
 }
-export declare enum TransitGatewayRouteState {
-  active = "active",
-  blackhole = "blackhole",
-  deleted = "deleted",
-  deleting = "deleting",
-  pending = "pending",
-}
+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 interface TransitGatewayRouteAttachment {
   ResourceId?: string;
   TransitGatewayAttachmentId?: string;
   ResourceType?: TransitGatewayAttachmentResourceType | string;
 }
-export declare enum TransitGatewayRouteType {
-  propagated = "propagated",
-  static = "static",
-}
+export declare const TransitGatewayRouteType: {
+  readonly propagated: "propagated";
+  readonly static: "static";
+};
+export type TransitGatewayRouteType =
+  (typeof TransitGatewayRouteType)[keyof typeof TransitGatewayRouteType];
 export interface TransitGatewayRoute {
   DestinationCidrBlock?: string;
   PrefixListId?: string;
@@ -725,12 +775,14 @@ export interface CreateTransitGatewayRouteTableRequest {
   TagSpecifications?: TagSpecification[];
   DryRun?: boolean;
 }
-export declare enum TransitGatewayRouteTableState {
-  available = "available",
-  deleted = "deleted",
-  deleting = "deleting",
-  pending = "pending",
-}
+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 interface TransitGatewayRouteTable {
   TransitGatewayRouteTableId?: string;
   TransitGatewayId?: string;
@@ -749,18 +801,22 @@ export interface CreateTransitGatewayRouteTableAnnouncementRequest {
   TagSpecifications?: TagSpecification[];
   DryRun?: boolean;
 }
-export declare enum TransitGatewayRouteTableAnnouncementDirection {
-  incoming = "incoming",
-  outgoing = "outgoing",
-}
-export declare enum TransitGatewayRouteTableAnnouncementState {
-  available = "available",
-  deleted = "deleted",
-  deleting = "deleting",
-  failed = "failed",
-  failing = "failing",
-  pending = "pending",
-}
+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 interface TransitGatewayRouteTableAnnouncement {
   TransitGatewayRouteTableAnnouncementId?: string;
   TransitGatewayId?: string;
@@ -795,17 +851,23 @@ export interface CreateTransitGatewayVpcAttachmentRequest {
 export interface CreateTransitGatewayVpcAttachmentResult {
   TransitGatewayVpcAttachment?: TransitGatewayVpcAttachment;
 }
-export declare enum VerifiedAccessEndpointAttachmentType {
-  vpc = "vpc",
-}
-export declare enum VerifiedAccessEndpointType {
-  load_balancer = "load-balancer",
-  network_interface = "network-interface",
-}
-export declare enum VerifiedAccessEndpointProtocol {
-  http = "http",
-  https = "https",
-}
+export declare const VerifiedAccessEndpointAttachmentType: {
+  readonly vpc: "vpc";
+};
+export type VerifiedAccessEndpointAttachmentType =
+  (typeof VerifiedAccessEndpointAttachmentType)[keyof typeof VerifiedAccessEndpointAttachmentType];
+export declare const VerifiedAccessEndpointType: {
+  readonly load_balancer: "load-balancer";
+  readonly network_interface: "network-interface";
+};
+export type VerifiedAccessEndpointType =
+  (typeof VerifiedAccessEndpointType)[keyof typeof VerifiedAccessEndpointType];
+export declare const VerifiedAccessEndpointProtocol: {
+  readonly http: "http";
+  readonly https: "https";
+};
+export type VerifiedAccessEndpointProtocol =
+  (typeof VerifiedAccessEndpointProtocol)[keyof typeof VerifiedAccessEndpointProtocol];
 export interface CreateVerifiedAccessEndpointLoadBalancerOptions {
   Protocol?: VerifiedAccessEndpointProtocol | string;
   Port?: number;
@@ -844,13 +906,15 @@ export interface VerifiedAccessEndpointEniOptions {
   Protocol?: VerifiedAccessEndpointProtocol | string;
   Port?: number;
 }
-export declare enum VerifiedAccessEndpointStatusCode {
-  active = "active",
-  deleted = "deleted",
-  deleting = "deleting",
-  pending = "pending",
-  updating = "updating",
-}
+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 interface VerifiedAccessEndpointStatus {
   Code?: VerifiedAccessEndpointStatusCode | string;
   Message?: string;
@@ -951,14 +1015,15 @@ export interface CreateVolumeRequest {
   Throughput?: number;
   ClientToken?: string;
 }
-export declare enum VolumeState {
-  available = "available",
-  creating = "creating",
-  deleted = "deleted",
-  deleting = "deleting",
-  error = "error",
-  in_use = "in-use",
-}
+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 interface Volume {
   Attachments?: VolumeAttachment[];
   AvailabilityZone?: string;
@@ -994,26 +1059,31 @@ export interface CreateVpcRequest {
 export interface CreateVpcResult {
   Vpc?: Vpc;
 }
-export declare enum DnsRecordIpType {
-  dualstack = "dualstack",
-  ipv4 = "ipv4",
-  ipv6 = "ipv6",
-  service_defined = "service-defined",
-}
+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 interface DnsOptionsSpecification {
   DnsRecordIpType?: DnsRecordIpType | string;
   PrivateDnsOnlyForInboundResolverEndpoint?: boolean;
 }
-export declare enum IpAddressType {
-  dualstack = "dualstack",
-  ipv4 = "ipv4",
-  ipv6 = "ipv6",
-}
-export declare enum VpcEndpointType {
-  Gateway = "Gateway",
-  GatewayLoadBalancer = "GatewayLoadBalancer",
-  Interface = "Interface",
-}
+export declare const IpAddressType: {
+  readonly dualstack: "dualstack";
+  readonly ipv4: "ipv4";
+  readonly ipv6: "ipv6";
+};
+export type IpAddressType = (typeof IpAddressType)[keyof typeof IpAddressType];
+export declare const VpcEndpointType: {
+  readonly Gateway: "Gateway";
+  readonly GatewayLoadBalancer: "GatewayLoadBalancer";
+  readonly Interface: "Interface";
+};
+export type VpcEndpointType =
+  (typeof VpcEndpointType)[keyof typeof VpcEndpointType];
 export interface CreateVpcEndpointRequest {
   DryRun?: boolean;
   VpcEndpointType?: VpcEndpointType | string;
@@ -1045,16 +1115,17 @@ export interface LastError {
   Message?: string;
   Code?: string;
 }
-export declare enum State {
-  Available = "Available",
-  Deleted = "Deleted",
-  Deleting = "Deleting",
-  Expired = "Expired",
-  Failed = "Failed",
-  Pending = "Pending",
-  PendingAcceptance = "PendingAcceptance",
-  Rejected = "Rejected",
-}
+export declare const State: {
+  readonly Available: "Available";
+  readonly Deleted: "Deleted";
+  readonly Deleting: "Deleting";
+  readonly Expired: "Expired";
+  readonly Failed: "Failed";
+  readonly Pending: "Pending";
+  readonly PendingAcceptance: "PendingAcceptance";
+  readonly Rejected: "Rejected";
+};
+export type State = (typeof State)[keyof typeof State];
 export interface VpcEndpoint {
   VpcEndpointId?: string;
   VpcEndpointType?: VpcEndpointType | string;
@@ -1088,13 +1159,17 @@ export interface CreateVpcEndpointConnectionNotificationRequest {
   ConnectionEvents: string[] | undefined;
   ClientToken?: string;
 }
-export declare enum ConnectionNotificationState {
-  Disabled = "Disabled",
-  Enabled = "Enabled",
-}
-export declare enum ConnectionNotificationType {
-  Topic = "Topic",
-}
+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 interface ConnectionNotification {
   ConnectionNotificationId?: string;
   ServiceId?: string;
@@ -1118,39 +1193,46 @@ export interface CreateVpcEndpointServiceConfigurationRequest {
   ClientToken?: string;
   TagSpecifications?: TagSpecification[];
 }
-export declare enum PayerResponsibility {
-  ServiceOwner = "ServiceOwner",
-}
-export declare enum DnsNameState {
-  Failed = "failed",
-  PendingVerification = "pendingVerification",
-  Verified = "verified",
-}
+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 interface PrivateDnsNameConfiguration {
   State?: DnsNameState | string;
   Type?: string;
   Value?: string;
   Name?: string;
 }
-export declare enum ServiceState {
-  Available = "Available",
-  Deleted = "Deleted",
-  Deleting = "Deleting",
-  Failed = "Failed",
-  Pending = "Pending",
-}
-export declare enum ServiceType {
-  Gateway = "Gateway",
-  GatewayLoadBalancer = "GatewayLoadBalancer",
-  Interface = "Interface",
-}
+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 interface ServiceTypeDetail {
   ServiceType?: ServiceType | string;
 }
-export declare enum ServiceConnectivityType {
-  ipv4 = "ipv4",
-  ipv6 = "ipv6",
-}
+export declare const ServiceConnectivityType: {
+  readonly ipv4: "ipv4";
+  readonly ipv6: "ipv6";
+};
+export type ServiceConnectivityType =
+  (typeof ServiceConnectivityType)[keyof typeof ServiceConnectivityType];
 export interface ServiceConfiguration {
   ServiceType?: ServiceTypeDetail[];
   ServiceId?: string;
@@ -1183,10 +1265,12 @@ export interface CreateVpcPeeringConnectionRequest {
 export interface CreateVpcPeeringConnectionResult {
   VpcPeeringConnection?: VpcPeeringConnection;
 }
-export declare enum TunnelInsideIpVersion {
-  ipv4 = "ipv4",
-  ipv6 = "ipv6",
-}
+export declare const TunnelInsideIpVersion: {
+  readonly ipv4: "ipv4";
+  readonly ipv6: "ipv6";
+};
+export type TunnelInsideIpVersion =
+  (typeof TunnelInsideIpVersion)[keyof typeof TunnelInsideIpVersion];
 export interface IKEVersionsRequestListValue {
   Value?: string;
 }
@@ -1236,6 +1320,7 @@ export interface VpnTunnelOptionsSpecification {
   IKEVersions?: IKEVersionsRequestListValue[];
   StartupAction?: string;
   LogOptions?: VpnTunnelLogOptionsSpecification;
+  EnableTunnelLifecycleControl?: boolean;
 }
 export interface VpnConnectionOptionsSpecification {
   EnableAcceleration?: boolean;
@@ -1258,12 +1343,14 @@ export interface CreateVpnConnectionRequest {
   Options?: VpnConnectionOptionsSpecification;
   TagSpecifications?: TagSpecification[];
 }
-export declare enum GatewayAssociationState {
-  associated = "associated",
-  associating = "associating",
-  disassociating = "disassociating",
-  not_associated = "not-associated",
-}
+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 interface IKEVersionsListValue {
   Value?: string;
 }
@@ -1314,6 +1401,7 @@ export interface TunnelOption {
   IkeVersions?: IKEVersionsListValue[];
   StartupAction?: string;
   LogOptions?: VpnTunnelLogOptions;
+  EnableTunnelLifecycleControl?: boolean;
 }
 export interface VpnConnectionOptions {
   EnableAcceleration?: boolean;
@@ -1327,24 +1415,29 @@ export interface VpnConnectionOptions {
   TunnelInsideIpVersion?: TunnelInsideIpVersion | string;
   TunnelOptions?: TunnelOption[];
 }
-export declare enum VpnStaticRouteSource {
-  Static = "Static",
-}
-export declare enum VpnState {
-  available = "available",
-  deleted = "deleted",
-  deleting = "deleting",
-  pending = "pending",
-}
+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 interface VpnStaticRoute {
   DestinationCidrBlock?: string;
   Source?: VpnStaticRouteSource | string;
   State?: VpnState | string;
 }
-export declare enum TelemetryStatus {
-  DOWN = "DOWN",
-  UP = "UP",
-}
+export declare const TelemetryStatus: {
+  readonly DOWN: "DOWN";
+  readonly UP: "UP";
+};
+export type TelemetryStatus =
+  (typeof TelemetryStatus)[keyof typeof TelemetryStatus];
 export interface VgwTelemetry {
   AcceptedRouteCount?: number;
   LastStatusChange?: Date;
@@ -1454,26 +1547,30 @@ export interface DeleteFleetsRequest {
   FleetIds: string[] | undefined;
   TerminateInstances: boolean | undefined;
 }
-export declare enum FleetStateCode {
-  ACTIVE = "active",
-  DELETED = "deleted",
-  DELETED_RUNNING = "deleted_running",
-  DELETED_TERMINATING_INSTANCES = "deleted_terminating",
-  FAILED = "failed",
-  MODIFYING = "modifying",
-  SUBMITTED = "submitted",
-}
+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 interface DeleteFleetSuccessItem {
   CurrentFleetState?: FleetStateCode | string;
   PreviousFleetState?: FleetStateCode | string;
   FleetId?: string;
 }
-export declare enum DeleteFleetErrorCode {
-  FLEET_ID_DOES_NOT_EXIST = "fleetIdDoesNotExist",
-  FLEET_ID_MALFORMED = "fleetIdMalformed",
-  FLEET_NOT_IN_DELETABLE_STATE = "fleetNotInDeletableState",
-  UNEXPECTED_ERROR = "unexpectedError",
-}
+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 interface DeleteFleetError {
   Code?: DeleteFleetErrorCode | string;
   Message?: string;
@@ -1569,14 +1666,16 @@ export interface DeleteLaunchTemplateVersionsResponseSuccessItem {
   LaunchTemplateName?: string;
   VersionNumber?: number;
 }
-export declare enum LaunchTemplateErrorCode {
-  LAUNCH_TEMPLATE_ID_DOES_NOT_EXIST = "launchTemplateIdDoesNotExist",
-  LAUNCH_TEMPLATE_ID_MALFORMED = "launchTemplateIdMalformed",
-  LAUNCH_TEMPLATE_NAME_DOES_NOT_EXIST = "launchTemplateNameDoesNotExist",
-  LAUNCH_TEMPLATE_NAME_MALFORMED = "launchTemplateNameMalformed",
-  LAUNCH_TEMPLATE_VERSION_DOES_NOT_EXIST = "launchTemplateVersionDoesNotExist",
-  UNEXPECTED_ERROR = "unexpectedError",
-}
+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 interface ResponseError {
   Code?: LaunchTemplateErrorCode | string;
   Message?: string;
@@ -1700,11 +1799,13 @@ export interface DeleteQueuedReservedInstancesRequest {
   DryRun?: boolean;
   ReservedInstancesIds: string[] | undefined;
 }
-export declare enum DeleteQueuedReservedInstancesErrorCode {
-  RESERVED_INSTANCES_ID_INVALID = "reserved-instances-id-invalid",
-  RESERVED_INSTANCES_NOT_IN_QUEUED_STATE = "reserved-instances-not-in-queued-state",
-  UNEXPECTED_ERROR = "unexpected-error",
-}
+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 interface DeleteQueuedReservedInstancesError {
   Code?: DeleteQueuedReservedInstancesErrorCode | string;
   Message?: string;