@aws-sdk/client-ec2 3.42.0 → 3.46.0

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

@@ -1,4 +1,354 @@
-import { _InstanceType, AcceleratorCount, AcceleratorManufacturer, AcceleratorName, AcceleratorTotalMemoryMiB, AcceleratorType, AddPrefixListEntry, ApplianceModeSupportValue, AttachmentStatus, BareMetal, BaselineEbsBandwidthMbps, BurstablePerformance, CpuManufacturer, CurrencyCodeValues, DnsSupportValue, FleetLaunchTemplateSpecification, InstanceEventWindow, InstanceGeneration, InstanceRequirementsRequest, InternetGatewayAttachment, Ipv4PrefixSpecification, Ipv6SupportValue, LocalStorage, LocalStorageType, MemoryGiBPerVCpu, ReservedInstancesListing, ResourceType, RouteTableAssociationState, Subnet, Tag, TagSpecification, Tenancy, TransitGatewayAttachmentResourceType, TransitGatewayAttachmentState, TransitGatewayPeeringAttachment, TransitGatewayVpcAttachment, UnsuccessfulItem, VolumeAttachment, Vpc, WeekDay } from "./models_0";
+import { _InstanceType, AcceleratorCount, AcceleratorCountRequest, AcceleratorManufacturer, AcceleratorName, AcceleratorTotalMemoryMiB, AcceleratorTotalMemoryMiBRequest, AcceleratorType, AccessScopePath, AccessScopePathRequest, AddIpamOperatingRegion, AddPrefixListEntry, AddressFamily, AttachmentStatus, BareMetal, BaselineEbsBandwidthMbpsRequest, BurstablePerformance, CpuManufacturer, CurrencyCodeValues, DnsSupportValue, FleetExcessCapacityTerminationPolicy, FleetLaunchTemplateSpecificationRequest, HostnameType, InstanceEventWindow, InstanceGeneration, InternetGatewayAttachment, Ipv4PrefixSpecification, LocalStorage, LocalStorageType, PortRange, Protocol, ReservedInstancesListing, ResourceType, RouteTableAssociationState, Subnet, Tag, TagSpecification, Tenancy, TransitGatewayAttachmentState, UnsuccessfulItem, WeekDay } from "./models_0";
+
+export interface MemoryGiBPerVCpuRequest {
+    
+    Min?: number;
+    
+    Max?: number;
+}
+export declare namespace MemoryGiBPerVCpuRequest {
+    
+    const filterSensitiveLog: (obj: MemoryGiBPerVCpuRequest) => any;
+}
+
+export interface MemoryMiBRequest {
+    
+    Min: number | undefined;
+    
+    Max?: number;
+}
+export declare namespace MemoryMiBRequest {
+    
+    const filterSensitiveLog: (obj: MemoryMiBRequest) => any;
+}
+
+export interface NetworkInterfaceCountRequest {
+    
+    Min?: number;
+    
+    Max?: number;
+}
+export declare namespace NetworkInterfaceCountRequest {
+    
+    const filterSensitiveLog: (obj: NetworkInterfaceCountRequest) => any;
+}
+
+export interface TotalLocalStorageGBRequest {
+    
+    Min?: number;
+    
+    Max?: number;
+}
+export declare namespace TotalLocalStorageGBRequest {
+    
+    const filterSensitiveLog: (obj: TotalLocalStorageGBRequest) => any;
+}
+
+export interface VCpuCountRangeRequest {
+    
+    Min: number | undefined;
+    
+    Max?: number;
+}
+export declare namespace VCpuCountRangeRequest {
+    
+    const filterSensitiveLog: (obj: VCpuCountRangeRequest) => any;
+}
+
+export interface InstanceRequirementsRequest {
+    
+    VCpuCount: VCpuCountRangeRequest | undefined;
+    
+    MemoryMiB: MemoryMiBRequest | undefined;
+    
+    CpuManufacturers?: (CpuManufacturer | string)[];
+    
+    MemoryGiBPerVCpu?: MemoryGiBPerVCpuRequest;
+    
+    ExcludedInstanceTypes?: string[];
+    
+    InstanceGenerations?: (InstanceGeneration | string)[];
+    
+    SpotMaxPricePercentageOverLowestPrice?: number;
+    
+    OnDemandMaxPricePercentageOverLowestPrice?: number;
+    
+    BareMetal?: BareMetal | string;
+    
+    BurstablePerformance?: BurstablePerformance | string;
+    
+    RequireHibernateSupport?: boolean;
+    
+    NetworkInterfaceCount?: NetworkInterfaceCountRequest;
+    
+    LocalStorage?: LocalStorage | string;
+    
+    LocalStorageTypes?: (LocalStorageType | string)[];
+    
+    TotalLocalStorageGB?: TotalLocalStorageGBRequest;
+    
+    BaselineEbsBandwidthMbps?: BaselineEbsBandwidthMbpsRequest;
+    
+    AcceleratorTypes?: (AcceleratorType | string)[];
+    
+    AcceleratorCount?: AcceleratorCountRequest;
+    
+    AcceleratorManufacturers?: (AcceleratorManufacturer | string)[];
+    
+    AcceleratorNames?: (AcceleratorName | string)[];
+    
+    AcceleratorTotalMemoryMiB?: AcceleratorTotalMemoryMiBRequest;
+}
+export declare namespace InstanceRequirementsRequest {
+    
+    const filterSensitiveLog: (obj: InstanceRequirementsRequest) => any;
+}
+
+export interface Placement {
+    
+    AvailabilityZone?: string;
+    
+    Affinity?: string;
+    
+    GroupName?: string;
+    
+    PartitionNumber?: number;
+    
+    HostId?: string;
+    
+    Tenancy?: Tenancy | string;
+    
+    SpreadDomain?: string;
+    
+    HostResourceGroupArn?: string;
+}
+export declare namespace Placement {
+    
+    const filterSensitiveLog: (obj: Placement) => any;
+}
+
+export interface FleetLaunchTemplateOverridesRequest {
+    
+    InstanceType?: _InstanceType | string;
+    
+    MaxPrice?: string;
+    
+    SubnetId?: string;
+    
+    AvailabilityZone?: string;
+    
+    WeightedCapacity?: number;
+    
+    Priority?: number;
+    
+    Placement?: Placement;
+    
+    InstanceRequirements?: InstanceRequirementsRequest;
+}
+export declare namespace FleetLaunchTemplateOverridesRequest {
+    
+    const filterSensitiveLog: (obj: FleetLaunchTemplateOverridesRequest) => any;
+}
+
+export interface FleetLaunchTemplateConfigRequest {
+    
+    LaunchTemplateSpecification?: FleetLaunchTemplateSpecificationRequest;
+    
+    Overrides?: FleetLaunchTemplateOverridesRequest[];
+}
+export declare namespace FleetLaunchTemplateConfigRequest {
+    
+    const filterSensitiveLog: (obj: FleetLaunchTemplateConfigRequest) => any;
+}
+export declare enum FleetOnDemandAllocationStrategy {
+    LOWEST_PRICE = "lowest-price",
+    PRIORITIZED = "prioritized"
+}
+export declare enum FleetCapacityReservationUsageStrategy {
+    USE_CAPACITY_RESERVATIONS_FIRST = "use-capacity-reservations-first"
+}
+
+export interface CapacityReservationOptionsRequest {
+    
+    UsageStrategy?: FleetCapacityReservationUsageStrategy | string;
+}
+export declare namespace CapacityReservationOptionsRequest {
+    
+    const filterSensitiveLog: (obj: CapacityReservationOptionsRequest) => any;
+}
+
+export interface OnDemandOptionsRequest {
+    
+    AllocationStrategy?: FleetOnDemandAllocationStrategy | string;
+    
+    CapacityReservationOptions?: CapacityReservationOptionsRequest;
+    
+    SingleInstanceType?: boolean;
+    
+    SingleAvailabilityZone?: boolean;
+    
+    MinTargetCapacity?: number;
+    
+    MaxTotalPrice?: string;
+}
+export declare namespace OnDemandOptionsRequest {
+    
+    const filterSensitiveLog: (obj: OnDemandOptionsRequest) => any;
+}
+export declare enum SpotAllocationStrategy {
+    CAPACITY_OPTIMIZED = "capacity-optimized",
+    CAPACITY_OPTIMIZED_PRIORITIZED = "capacity-optimized-prioritized",
+    DIVERSIFIED = "diversified",
+    LOWEST_PRICE = "lowest-price"
+}
+export declare type SpotInstanceInterruptionBehavior = "hibernate" | "stop" | "terminate";
+export declare enum FleetReplacementStrategy {
+    LAUNCH = "launch",
+    LAUNCH_BEFORE_TERMINATE = "launch-before-terminate"
+}
+
+export interface FleetSpotCapacityRebalanceRequest {
+    
+    ReplacementStrategy?: FleetReplacementStrategy | string;
+    
+    TerminationDelay?: number;
+}
+export declare namespace FleetSpotCapacityRebalanceRequest {
+    
+    const filterSensitiveLog: (obj: FleetSpotCapacityRebalanceRequest) => any;
+}
+
+export interface FleetSpotMaintenanceStrategiesRequest {
+    
+    CapacityRebalance?: FleetSpotCapacityRebalanceRequest;
+}
+export declare namespace FleetSpotMaintenanceStrategiesRequest {
+    
+    const filterSensitiveLog: (obj: FleetSpotMaintenanceStrategiesRequest) => any;
+}
+
+export interface SpotOptionsRequest {
+    
+    AllocationStrategy?: SpotAllocationStrategy | string;
+    
+    MaintenanceStrategies?: FleetSpotMaintenanceStrategiesRequest;
+    
+    InstanceInterruptionBehavior?: SpotInstanceInterruptionBehavior | string;
+    
+    InstancePoolsToUseCount?: number;
+    
+    SingleInstanceType?: boolean;
+    
+    SingleAvailabilityZone?: boolean;
+    
+    MinTargetCapacity?: number;
+    
+    MaxTotalPrice?: string;
+}
+export declare namespace SpotOptionsRequest {
+    
+    const filterSensitiveLog: (obj: SpotOptionsRequest) => any;
+}
+export declare enum DefaultTargetCapacityType {
+    ON_DEMAND = "on-demand",
+    SPOT = "spot"
+}
+export declare enum TargetCapacityUnitType {
+    MEMORY_MIB = "memory-mib",
+    UNITS = "units",
+    VCPU = "vcpu"
+}
+
+export interface TargetCapacitySpecificationRequest {
+    
+    TotalTargetCapacity: number | undefined;
+    
+    OnDemandTargetCapacity?: number;
+    
+    SpotTargetCapacity?: number;
+    
+    DefaultTargetCapacityType?: DefaultTargetCapacityType | string;
+    
+    TargetCapacityUnitType?: TargetCapacityUnitType | string;
+}
+export declare namespace TargetCapacitySpecificationRequest {
+    
+    const filterSensitiveLog: (obj: TargetCapacitySpecificationRequest) => any;
+}
+export declare enum FleetType {
+    INSTANT = "instant",
+    MAINTAIN = "maintain",
+    REQUEST = "request"
+}
+export interface CreateFleetRequest {
+    
+    DryRun?: boolean;
+    
+    ClientToken?: string;
+    
+    SpotOptions?: SpotOptionsRequest;
+    
+    OnDemandOptions?: OnDemandOptionsRequest;
+    
+    ExcessCapacityTerminationPolicy?: FleetExcessCapacityTerminationPolicy | string;
+    
+    LaunchTemplateConfigs: FleetLaunchTemplateConfigRequest[] | undefined;
+    
+    TargetCapacitySpecification: TargetCapacitySpecificationRequest | undefined;
+    
+    TerminateInstancesWithExpiration?: boolean;
+    
+    Type?: FleetType | string;
+    
+    ValidFrom?: Date;
+    
+    ValidUntil?: Date;
+    
+    ReplaceUnhealthyInstances?: boolean;
+    
+    TagSpecifications?: TagSpecification[];
+    
+    Context?: string;
+}
+export declare namespace CreateFleetRequest {
+    
+    const filterSensitiveLog: (obj: CreateFleetRequest) => any;
+}
+
+export interface FleetLaunchTemplateSpecification {
+    
+    LaunchTemplateId?: string;
+    
+    LaunchTemplateName?: string;
+    
+    Version?: string;
+}
+export declare namespace FleetLaunchTemplateSpecification {
+    
+    const filterSensitiveLog: (obj: FleetLaunchTemplateSpecification) => any;
+}
+
+export interface BaselineEbsBandwidthMbps {
+    
+    Min?: number;
+    
+    Max?: number;
+}
+export declare namespace BaselineEbsBandwidthMbps {
+    
+    const filterSensitiveLog: (obj: BaselineEbsBandwidthMbps) => any;
+}
+
+export interface MemoryGiBPerVCpu {
+    
+    Min?: number;
+    
+    Max?: number;
+}
+export declare namespace MemoryGiBPerVCpu {
+    
+    const filterSensitiveLog: (obj: MemoryGiBPerVCpu) => any;
+}
 
 export interface MemoryMiB {
     
@@ -520,51 +870,323 @@ export declare namespace CreateInternetGatewayResult {
     
     const filterSensitiveLog: (obj: CreateInternetGatewayResult) => any;
 }
-export declare enum KeyType {
-    ed25519 = "ed25519",
-    rsa = "rsa"
-}
-export interface CreateKeyPairRequest {
-    
-    KeyName: string | undefined;
+export interface CreateIpamRequest {
     
     DryRun?: boolean;
     
-    KeyType?: KeyType | string;
+    Description?: string;
+    
+    OperatingRegions?: AddIpamOperatingRegion[];
     
     TagSpecifications?: TagSpecification[];
+    
+    ClientToken?: string;
 }
-export declare namespace CreateKeyPairRequest {
+export declare namespace CreateIpamRequest {
     
-    const filterSensitiveLog: (obj: CreateKeyPairRequest) => any;
+    const filterSensitiveLog: (obj: CreateIpamRequest) => any;
 }
 
-export interface KeyPair {
-    
-    KeyFingerprint?: string;
+export interface IpamOperatingRegion {
     
-    KeyMaterial?: string;
-    
-    KeyName?: string;
-    
-    KeyPairId?: string;
-    
-    Tags?: Tag[];
+    RegionName?: string;
 }
-export declare namespace KeyPair {
+export declare namespace IpamOperatingRegion {
     
-    const filterSensitiveLog: (obj: KeyPair) => any;
+    const filterSensitiveLog: (obj: IpamOperatingRegion) => any;
+}
+export declare enum IpamState {
+    create_complete = "create-complete",
+    create_failed = "create-failed",
+    create_in_progress = "create-in-progress",
+    delete_complete = "delete-complete",
+    delete_failed = "delete-failed",
+    delete_in_progress = "delete-in-progress",
+    modify_complete = "modify-complete",
+    modify_failed = "modify-failed",
+    modify_in_progress = "modify-in-progress"
 }
 
-export interface LaunchTemplateEbsBlockDeviceRequest {
+export interface Ipam {
     
-    Encrypted?: boolean;
+    OwnerId?: string;
     
-    DeleteOnTermination?: boolean;
+    IpamId?: string;
     
-    Iops?: number;
+    IpamArn?: string;
     
-    KmsKeyId?: string;
+    IpamRegion?: string;
+    
+    PublicDefaultScopeId?: string;
+    
+    PrivateDefaultScopeId?: string;
+    
+    ScopeCount?: number;
+    
+    Description?: string;
+    
+    OperatingRegions?: IpamOperatingRegion[];
+    
+    State?: IpamState | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace Ipam {
+    
+    const filterSensitiveLog: (obj: Ipam) => any;
+}
+export interface CreateIpamResult {
+    
+    Ipam?: Ipam;
+}
+export declare namespace CreateIpamResult {
+    
+    const filterSensitiveLog: (obj: CreateIpamResult) => any;
+}
+
+export interface RequestIpamResourceTag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace RequestIpamResourceTag {
+    
+    const filterSensitiveLog: (obj: RequestIpamResourceTag) => any;
+}
+export declare enum IpamPoolAwsService {
+    ec2 = "ec2"
+}
+export interface CreateIpamPoolRequest {
+    
+    DryRun?: boolean;
+    
+    IpamScopeId: string | undefined;
+    
+    Locale?: string;
+    
+    SourceIpamPoolId?: string;
+    
+    Description?: string;
+    
+    AddressFamily?: AddressFamily | string;
+    
+    AutoImport?: boolean;
+    
+    PubliclyAdvertisable?: boolean;
+    
+    AllocationMinNetmaskLength?: number;
+    
+    AllocationMaxNetmaskLength?: number;
+    
+    AllocationDefaultNetmaskLength?: number;
+    
+    AllocationResourceTags?: RequestIpamResourceTag[];
+    
+    TagSpecifications?: TagSpecification[];
+    
+    ClientToken?: string;
+    
+    AwsService?: IpamPoolAwsService | string;
+}
+export declare namespace CreateIpamPoolRequest {
+    
+    const filterSensitiveLog: (obj: CreateIpamPoolRequest) => any;
+}
+
+export interface IpamResourceTag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace IpamResourceTag {
+    
+    const filterSensitiveLog: (obj: IpamResourceTag) => any;
+}
+export declare enum IpamScopeType {
+    private = "private",
+    public = "public"
+}
+export declare enum IpamPoolState {
+    create_complete = "create-complete",
+    create_failed = "create-failed",
+    create_in_progress = "create-in-progress",
+    delete_complete = "delete-complete",
+    delete_failed = "delete-failed",
+    delete_in_progress = "delete-in-progress",
+    modify_complete = "modify-complete",
+    modify_failed = "modify-failed",
+    modify_in_progress = "modify-in-progress"
+}
+
+export interface IpamPool {
+    
+    OwnerId?: string;
+    
+    IpamPoolId?: string;
+    
+    SourceIpamPoolId?: string;
+    
+    IpamPoolArn?: string;
+    
+    IpamScopeArn?: string;
+    
+    IpamScopeType?: IpamScopeType | string;
+    
+    IpamArn?: string;
+    
+    IpamRegion?: string;
+    
+    Locale?: string;
+    
+    PoolDepth?: number;
+    
+    State?: IpamPoolState | string;
+    
+    StateMessage?: string;
+    
+    Description?: string;
+    
+    AutoImport?: boolean;
+    
+    PubliclyAdvertisable?: boolean;
+    
+    AddressFamily?: AddressFamily | string;
+    
+    AllocationMinNetmaskLength?: number;
+    
+    AllocationMaxNetmaskLength?: number;
+    
+    AllocationDefaultNetmaskLength?: number;
+    
+    AllocationResourceTags?: IpamResourceTag[];
+    
+    Tags?: Tag[];
+    
+    AwsService?: IpamPoolAwsService | string;
+}
+export declare namespace IpamPool {
+    
+    const filterSensitiveLog: (obj: IpamPool) => any;
+}
+export interface CreateIpamPoolResult {
+    
+    IpamPool?: IpamPool;
+}
+export declare namespace CreateIpamPoolResult {
+    
+    const filterSensitiveLog: (obj: CreateIpamPoolResult) => any;
+}
+export interface CreateIpamScopeRequest {
+    
+    DryRun?: boolean;
+    
+    IpamId: string | undefined;
+    
+    Description?: string;
+    
+    TagSpecifications?: TagSpecification[];
+    
+    ClientToken?: string;
+}
+export declare namespace CreateIpamScopeRequest {
+    
+    const filterSensitiveLog: (obj: CreateIpamScopeRequest) => any;
+}
+export declare enum IpamScopeState {
+    create_complete = "create-complete",
+    create_failed = "create-failed",
+    create_in_progress = "create-in-progress",
+    delete_complete = "delete-complete",
+    delete_failed = "delete-failed",
+    delete_in_progress = "delete-in-progress",
+    modify_complete = "modify-complete",
+    modify_failed = "modify-failed",
+    modify_in_progress = "modify-in-progress"
+}
+
+export interface IpamScope {
+    
+    OwnerId?: string;
+    
+    IpamScopeId?: string;
+    
+    IpamScopeArn?: string;
+    
+    IpamArn?: string;
+    
+    IpamRegion?: string;
+    
+    IpamScopeType?: IpamScopeType | string;
+    
+    IsDefault?: boolean;
+    
+    Description?: string;
+    
+    PoolCount?: number;
+    
+    State?: IpamScopeState | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace IpamScope {
+    
+    const filterSensitiveLog: (obj: IpamScope) => any;
+}
+export interface CreateIpamScopeResult {
+    
+    IpamScope?: IpamScope;
+}
+export declare namespace CreateIpamScopeResult {
+    
+    const filterSensitiveLog: (obj: CreateIpamScopeResult) => any;
+}
+export declare enum KeyType {
+    ed25519 = "ed25519",
+    rsa = "rsa"
+}
+export interface CreateKeyPairRequest {
+    
+    KeyName: string | undefined;
+    
+    DryRun?: boolean;
+    
+    KeyType?: KeyType | string;
+    
+    TagSpecifications?: TagSpecification[];
+}
+export declare namespace CreateKeyPairRequest {
+    
+    const filterSensitiveLog: (obj: CreateKeyPairRequest) => any;
+}
+
+export interface KeyPair {
+    
+    KeyFingerprint?: string;
+    
+    KeyMaterial?: string;
+    
+    KeyName?: string;
+    
+    KeyPairId?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace KeyPair {
+    
+    const filterSensitiveLog: (obj: KeyPair) => any;
+}
+
+export interface LaunchTemplateEbsBlockDeviceRequest {
+    
+    Encrypted?: boolean;
+    
+    DeleteOnTermination?: boolean;
+    
+    Iops?: number;
+    
+    KmsKeyId?: string;
     
     SnapshotId?: string;
     
@@ -735,6 +1357,10 @@ export declare enum LaunchTemplateHttpTokensState {
     optional = "optional",
     required = "required"
 }
+export declare enum LaunchTemplateInstanceMetadataTagsState {
+    disabled = "disabled",
+    enabled = "enabled"
+}
 
 export interface LaunchTemplateInstanceMetadataOptionsRequest {
     
@@ -745,6 +1371,8 @@ export interface LaunchTemplateInstanceMetadataOptionsRequest {
     HttpEndpoint?: LaunchTemplateInstanceMetadataEndpointState | string;
     
     HttpProtocolIpv6?: LaunchTemplateInstanceMetadataProtocolIpv6 | string;
+    
+    InstanceMetadataTags?: LaunchTemplateInstanceMetadataTagsState | string;
 }
 export declare namespace LaunchTemplateInstanceMetadataOptionsRequest {
     
@@ -866,6 +1494,19 @@ export declare namespace LaunchTemplatePlacementRequest {
     const filterSensitiveLog: (obj: LaunchTemplatePlacementRequest) => any;
 }
 
+export interface LaunchTemplatePrivateDnsNameOptionsRequest {
+    
+    HostnameType?: HostnameType | string;
+    
+    EnableResourceNameDnsARecord?: boolean;
+    
+    EnableResourceNameDnsAAAARecord?: boolean;
+}
+export declare namespace LaunchTemplatePrivateDnsNameOptionsRequest {
+    
+    const filterSensitiveLog: (obj: LaunchTemplatePrivateDnsNameOptionsRequest) => any;
+}
+
 export interface LaunchTemplateTagSpecificationRequest {
     
     ResourceType?: ResourceType | string;
@@ -934,6 +1575,8 @@ export interface RequestLaunchTemplateData {
     EnclaveOptions?: LaunchTemplateEnclaveOptionsRequest;
     
     InstanceRequirements?: InstanceRequirementsRequest;
+    
+    PrivateDnsNameOptions?: LaunchTemplatePrivateDnsNameOptionsRequest;
 }
 export declare namespace RequestLaunchTemplateData {
     
@@ -1207,6 +1850,8 @@ export interface LaunchTemplateInstanceMetadataOptions {
     HttpEndpoint?: LaunchTemplateInstanceMetadataEndpointState | string;
     
     HttpProtocolIpv6?: LaunchTemplateInstanceMetadataProtocolIpv6 | string;
+    
+    InstanceMetadataTags?: LaunchTemplateInstanceMetadataTagsState | string;
 }
 export declare namespace LaunchTemplateInstanceMetadataOptions {
     
@@ -1317,6 +1962,19 @@ export declare namespace LaunchTemplatePlacement {
     const filterSensitiveLog: (obj: LaunchTemplatePlacement) => any;
 }
 
+export interface LaunchTemplatePrivateDnsNameOptions {
+    
+    HostnameType?: HostnameType | string;
+    
+    EnableResourceNameDnsARecord?: boolean;
+    
+    EnableResourceNameDnsAAAARecord?: boolean;
+}
+export declare namespace LaunchTemplatePrivateDnsNameOptions {
+    
+    const filterSensitiveLog: (obj: LaunchTemplatePrivateDnsNameOptions) => any;
+}
+
 export interface LaunchTemplateTagSpecification {
     
     ResourceType?: ResourceType | string;
@@ -1385,6 +2043,8 @@ export interface ResponseLaunchTemplateData {
     EnclaveOptions?: LaunchTemplateEnclaveOptions;
     
     InstanceRequirements?: InstanceRequirements;
+    
+    PrivateDnsNameOptions?: LaunchTemplatePrivateDnsNameOptions;
 }
 export declare namespace ResponseLaunchTemplateData {
     
@@ -1707,17 +2367,6 @@ export declare namespace IcmpTypeCode {
     
     const filterSensitiveLog: (obj: IcmpTypeCode) => any;
 }
-
-export interface PortRange {
-    
-    From?: number;
-    
-    To?: number;
-}
-export declare namespace PortRange {
-    
-    const filterSensitiveLog: (obj: PortRange) => any;
-}
 export declare type RuleAction = "allow" | "deny";
 
 export interface NetworkAclEntry {
@@ -1797,7 +2446,62 @@ export declare namespace CreateNetworkAclEntryRequest {
     
     const filterSensitiveLog: (obj: CreateNetworkAclEntryRequest) => any;
 }
-export declare type Protocol = "tcp" | "udp";
+export interface CreateNetworkInsightsAccessScopeRequest {
+    
+    MatchPaths?: AccessScopePathRequest[];
+    
+    ExcludePaths?: AccessScopePathRequest[];
+    
+    ClientToken?: string;
+    
+    TagSpecifications?: TagSpecification[];
+    
+    DryRun?: boolean;
+}
+export declare namespace CreateNetworkInsightsAccessScopeRequest {
+    
+    const filterSensitiveLog: (obj: CreateNetworkInsightsAccessScopeRequest) => any;
+}
+
+export interface NetworkInsightsAccessScope {
+    
+    NetworkInsightsAccessScopeId?: string;
+    
+    NetworkInsightsAccessScopeArn?: string;
+    
+    CreatedDate?: Date;
+    
+    UpdatedDate?: Date;
+    
+    Tags?: Tag[];
+}
+export declare namespace NetworkInsightsAccessScope {
+    
+    const filterSensitiveLog: (obj: NetworkInsightsAccessScope) => any;
+}
+
+export interface NetworkInsightsAccessScopeContent {
+    
+    NetworkInsightsAccessScopeId?: string;
+    
+    MatchPaths?: AccessScopePath[];
+    
+    ExcludePaths?: AccessScopePath[];
+}
+export declare namespace NetworkInsightsAccessScopeContent {
+    
+    const filterSensitiveLog: (obj: NetworkInsightsAccessScopeContent) => any;
+}
+export interface CreateNetworkInsightsAccessScopeResult {
+    
+    NetworkInsightsAccessScope?: NetworkInsightsAccessScope;
+    
+    NetworkInsightsAccessScopeContent?: NetworkInsightsAccessScopeContent;
+}
+export declare namespace CreateNetworkInsightsAccessScopeResult {
+    
+    const filterSensitiveLog: (obj: CreateNetworkInsightsAccessScopeResult) => any;
+}
 export interface CreateNetworkInsightsPathRequest {
     
     SourceIp?: string;
@@ -2037,6 +2741,10 @@ export interface NetworkInterface {
     VpcId?: string;
     
     DenyAllIgwTraffic?: boolean;
+    
+    Ipv6Native?: boolean;
+    
+    Ipv6Address?: string;
 }
 export declare namespace NetworkInterface {
     
@@ -2143,6 +2851,8 @@ export interface PlacementGroup {
     GroupId?: string;
     
     Tags?: Tag[];
+    
+    GroupArn?: string;
 }
 export declare namespace PlacementGroup {
     
@@ -2156,6 +2866,24 @@ export declare namespace CreatePlacementGroupResult {
     
     const filterSensitiveLog: (obj: CreatePlacementGroupResult) => any;
 }
+export interface CreatePublicIpv4PoolRequest {
+    
+    DryRun?: boolean;
+    
+    TagSpecifications?: TagSpecification[];
+}
+export declare namespace CreatePublicIpv4PoolRequest {
+    
+    const filterSensitiveLog: (obj: CreatePublicIpv4PoolRequest) => any;
+}
+export interface CreatePublicIpv4PoolResult {
+    
+    PoolId?: string;
+}
+export declare namespace CreatePublicIpv4PoolResult {
+    
+    const filterSensitiveLog: (obj: CreatePublicIpv4PoolResult) => any;
+}
 export interface CreateReplaceRootVolumeTaskRequest {
     
     InstanceId: string | undefined;
@@ -2299,6 +3027,7 @@ export interface CreateRouteRequest {
     RouteTableId: string | undefined;
     
     VpcPeeringConnectionId?: string;
+    
     CoreNetworkArn?: string;
 }
 export declare namespace CreateRouteRequest {
@@ -2387,6 +3116,7 @@ export interface Route {
     State?: RouteState | string;
     
     VpcPeeringConnectionId?: string;
+    
     CoreNetworkArn?: string;
 }
 export declare namespace Route {
@@ -2464,7 +3194,11 @@ export declare namespace CreateSnapshotRequest {
     
     const filterSensitiveLog: (obj: CreateSnapshotRequest) => any;
 }
-export declare type SnapshotState = "completed" | "error" | "pending";
+export declare type SnapshotState = "completed" | "error" | "pending" | "recoverable" | "recovering";
+export declare enum StorageTier {
+    archive = "archive",
+    standard = "standard"
+}
 
 export interface Snapshot {
     
@@ -2497,6 +3231,10 @@ export interface Snapshot {
     OutpostArn?: string;
     
     Tags?: Tag[];
+    
+    StorageTier?: StorageTier | string;
+    
+    RestoreExpiryTime?: Date;
 }
 export declare namespace Snapshot {
     
@@ -2661,7 +3399,7 @@ export interface CreateSubnetRequest {
     
     AvailabilityZoneId?: string;
     
-    CidrBlock: string | undefined;
+    CidrBlock?: string;
     
     Ipv6CidrBlock?: string;
     
@@ -2670,6 +3408,8 @@ export interface CreateSubnetRequest {
     VpcId: string | undefined;
     
     DryRun?: boolean;
+    
+    Ipv6Native?: boolean;
 }
 export declare namespace CreateSubnetRequest {
     
@@ -3189,647 +3929,3 @@ export declare namespace CreateTransitGatewayConnectPeerRequest {
     const filterSensitiveLog: (obj: CreateTransitGatewayConnectPeerRequest) => any;
 }
 export declare type BgpStatus = "down" | "up";
-
-export interface TransitGatewayAttachmentBgpConfiguration {
-    
-    TransitGatewayAsn?: number;
-    
-    PeerAsn?: number;
-    
-    TransitGatewayAddress?: string;
-    
-    PeerAddress?: string;
-    
-    BgpStatus?: BgpStatus | string;
-}
-export declare namespace TransitGatewayAttachmentBgpConfiguration {
-    
-    const filterSensitiveLog: (obj: TransitGatewayAttachmentBgpConfiguration) => any;
-}
-
-export interface TransitGatewayConnectPeerConfiguration {
-    
-    TransitGatewayAddress?: string;
-    
-    PeerAddress?: string;
-    
-    InsideCidrBlocks?: string[];
-    
-    Protocol?: ProtocolValue | string;
-    
-    BgpConfigurations?: TransitGatewayAttachmentBgpConfiguration[];
-}
-export declare namespace TransitGatewayConnectPeerConfiguration {
-    
-    const filterSensitiveLog: (obj: TransitGatewayConnectPeerConfiguration) => any;
-}
-export declare type TransitGatewayConnectPeerState = "available" | "deleted" | "deleting" | "pending";
-
-export interface TransitGatewayConnectPeer {
-    
-    TransitGatewayAttachmentId?: string;
-    
-    TransitGatewayConnectPeerId?: string;
-    
-    State?: TransitGatewayConnectPeerState | string;
-    
-    CreationTime?: Date;
-    
-    ConnectPeerConfiguration?: TransitGatewayConnectPeerConfiguration;
-    
-    Tags?: Tag[];
-}
-export declare namespace TransitGatewayConnectPeer {
-    
-    const filterSensitiveLog: (obj: TransitGatewayConnectPeer) => any;
-}
-export interface CreateTransitGatewayConnectPeerResult {
-    
-    TransitGatewayConnectPeer?: TransitGatewayConnectPeer;
-}
-export declare namespace CreateTransitGatewayConnectPeerResult {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayConnectPeerResult) => any;
-}
-export declare type AutoAcceptSharedAssociationsValue = "disable" | "enable";
-export declare type Igmpv2SupportValue = "disable" | "enable";
-export declare type StaticSourcesSupportValue = "disable" | "enable";
-
-export interface CreateTransitGatewayMulticastDomainRequestOptions {
-    
-    Igmpv2Support?: Igmpv2SupportValue | string;
-    
-    StaticSourcesSupport?: StaticSourcesSupportValue | string;
-    
-    AutoAcceptSharedAssociations?: AutoAcceptSharedAssociationsValue | string;
-}
-export declare namespace CreateTransitGatewayMulticastDomainRequestOptions {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayMulticastDomainRequestOptions) => any;
-}
-export interface CreateTransitGatewayMulticastDomainRequest {
-    
-    TransitGatewayId: string | undefined;
-    
-    Options?: CreateTransitGatewayMulticastDomainRequestOptions;
-    
-    TagSpecifications?: TagSpecification[];
-    
-    DryRun?: boolean;
-}
-export declare namespace CreateTransitGatewayMulticastDomainRequest {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayMulticastDomainRequest) => any;
-}
-
-export interface TransitGatewayMulticastDomainOptions {
-    
-    Igmpv2Support?: Igmpv2SupportValue | string;
-    
-    StaticSourcesSupport?: StaticSourcesSupportValue | string;
-    
-    AutoAcceptSharedAssociations?: AutoAcceptSharedAssociationsValue | string;
-}
-export declare namespace TransitGatewayMulticastDomainOptions {
-    
-    const filterSensitiveLog: (obj: TransitGatewayMulticastDomainOptions) => any;
-}
-export declare type TransitGatewayMulticastDomainState = "available" | "deleted" | "deleting" | "pending";
-
-export interface TransitGatewayMulticastDomain {
-    
-    TransitGatewayMulticastDomainId?: string;
-    
-    TransitGatewayId?: string;
-    
-    TransitGatewayMulticastDomainArn?: string;
-    
-    OwnerId?: string;
-    
-    Options?: TransitGatewayMulticastDomainOptions;
-    
-    State?: TransitGatewayMulticastDomainState | string;
-    
-    CreationTime?: Date;
-    
-    Tags?: Tag[];
-}
-export declare namespace TransitGatewayMulticastDomain {
-    
-    const filterSensitiveLog: (obj: TransitGatewayMulticastDomain) => any;
-}
-export interface CreateTransitGatewayMulticastDomainResult {
-    
-    TransitGatewayMulticastDomain?: TransitGatewayMulticastDomain;
-}
-export declare namespace CreateTransitGatewayMulticastDomainResult {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayMulticastDomainResult) => any;
-}
-export interface CreateTransitGatewayPeeringAttachmentRequest {
-    
-    TransitGatewayId: string | undefined;
-    
-    PeerTransitGatewayId: string | undefined;
-    
-    PeerAccountId: string | undefined;
-    
-    PeerRegion: string | undefined;
-    
-    TagSpecifications?: TagSpecification[];
-    
-    DryRun?: boolean;
-}
-export declare namespace CreateTransitGatewayPeeringAttachmentRequest {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayPeeringAttachmentRequest) => any;
-}
-export interface CreateTransitGatewayPeeringAttachmentResult {
-    
-    TransitGatewayPeeringAttachment?: TransitGatewayPeeringAttachment;
-}
-export declare namespace CreateTransitGatewayPeeringAttachmentResult {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayPeeringAttachmentResult) => any;
-}
-export interface CreateTransitGatewayPrefixListReferenceRequest {
-    
-    TransitGatewayRouteTableId: string | undefined;
-    
-    PrefixListId: string | undefined;
-    
-    TransitGatewayAttachmentId?: string;
-    
-    Blackhole?: boolean;
-    
-    DryRun?: boolean;
-}
-export declare namespace CreateTransitGatewayPrefixListReferenceRequest {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayPrefixListReferenceRequest) => any;
-}
-export declare type TransitGatewayPrefixListReferenceState = "available" | "deleting" | "modifying" | "pending";
-
-export interface TransitGatewayPrefixListAttachment {
-    
-    TransitGatewayAttachmentId?: string;
-    
-    ResourceType?: TransitGatewayAttachmentResourceType | string;
-    
-    ResourceId?: string;
-}
-export declare namespace TransitGatewayPrefixListAttachment {
-    
-    const filterSensitiveLog: (obj: TransitGatewayPrefixListAttachment) => any;
-}
-
-export interface TransitGatewayPrefixListReference {
-    
-    TransitGatewayRouteTableId?: string;
-    
-    PrefixListId?: string;
-    
-    PrefixListOwnerId?: string;
-    
-    State?: TransitGatewayPrefixListReferenceState | string;
-    
-    Blackhole?: boolean;
-    
-    TransitGatewayAttachment?: TransitGatewayPrefixListAttachment;
-}
-export declare namespace TransitGatewayPrefixListReference {
-    
-    const filterSensitiveLog: (obj: TransitGatewayPrefixListReference) => any;
-}
-export interface CreateTransitGatewayPrefixListReferenceResult {
-    
-    TransitGatewayPrefixListReference?: TransitGatewayPrefixListReference;
-}
-export declare namespace CreateTransitGatewayPrefixListReferenceResult {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayPrefixListReferenceResult) => any;
-}
-export interface CreateTransitGatewayRouteRequest {
-    
-    DestinationCidrBlock: string | undefined;
-    
-    TransitGatewayRouteTableId: string | undefined;
-    
-    TransitGatewayAttachmentId?: string;
-    
-    Blackhole?: boolean;
-    
-    DryRun?: boolean;
-}
-export declare namespace CreateTransitGatewayRouteRequest {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayRouteRequest) => any;
-}
-export declare type TransitGatewayRouteState = "active" | "blackhole" | "deleted" | "deleting" | "pending";
-
-export interface TransitGatewayRouteAttachment {
-    
-    ResourceId?: string;
-    
-    TransitGatewayAttachmentId?: string;
-    
-    ResourceType?: TransitGatewayAttachmentResourceType | string;
-}
-export declare namespace TransitGatewayRouteAttachment {
-    
-    const filterSensitiveLog: (obj: TransitGatewayRouteAttachment) => any;
-}
-export declare type TransitGatewayRouteType = "propagated" | "static";
-
-export interface TransitGatewayRoute {
-    
-    DestinationCidrBlock?: string;
-    
-    PrefixListId?: string;
-    
-    TransitGatewayAttachments?: TransitGatewayRouteAttachment[];
-    
-    Type?: TransitGatewayRouteType | string;
-    
-    State?: TransitGatewayRouteState | string;
-}
-export declare namespace TransitGatewayRoute {
-    
-    const filterSensitiveLog: (obj: TransitGatewayRoute) => any;
-}
-export interface CreateTransitGatewayRouteResult {
-    
-    Route?: TransitGatewayRoute;
-}
-export declare namespace CreateTransitGatewayRouteResult {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayRouteResult) => any;
-}
-export interface CreateTransitGatewayRouteTableRequest {
-    
-    TransitGatewayId: string | undefined;
-    
-    TagSpecifications?: TagSpecification[];
-    
-    DryRun?: boolean;
-}
-export declare namespace CreateTransitGatewayRouteTableRequest {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayRouteTableRequest) => any;
-}
-export declare type TransitGatewayRouteTableState = "available" | "deleted" | "deleting" | "pending";
-
-export interface TransitGatewayRouteTable {
-    
-    TransitGatewayRouteTableId?: string;
-    
-    TransitGatewayId?: string;
-    
-    State?: TransitGatewayRouteTableState | string;
-    
-    DefaultAssociationRouteTable?: boolean;
-    
-    DefaultPropagationRouteTable?: boolean;
-    
-    CreationTime?: Date;
-    
-    Tags?: Tag[];
-}
-export declare namespace TransitGatewayRouteTable {
-    
-    const filterSensitiveLog: (obj: TransitGatewayRouteTable) => any;
-}
-export interface CreateTransitGatewayRouteTableResult {
-    
-    TransitGatewayRouteTable?: TransitGatewayRouteTable;
-}
-export declare namespace CreateTransitGatewayRouteTableResult {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayRouteTableResult) => any;
-}
-
-export interface CreateTransitGatewayVpcAttachmentRequestOptions {
-    
-    DnsSupport?: DnsSupportValue | string;
-    
-    Ipv6Support?: Ipv6SupportValue | string;
-    
-    ApplianceModeSupport?: ApplianceModeSupportValue | string;
-}
-export declare namespace CreateTransitGatewayVpcAttachmentRequestOptions {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayVpcAttachmentRequestOptions) => any;
-}
-export interface CreateTransitGatewayVpcAttachmentRequest {
-    
-    TransitGatewayId: string | undefined;
-    
-    VpcId: string | undefined;
-    
-    SubnetIds: string[] | undefined;
-    
-    Options?: CreateTransitGatewayVpcAttachmentRequestOptions;
-    
-    TagSpecifications?: TagSpecification[];
-    
-    DryRun?: boolean;
-}
-export declare namespace CreateTransitGatewayVpcAttachmentRequest {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayVpcAttachmentRequest) => any;
-}
-export interface CreateTransitGatewayVpcAttachmentResult {
-    
-    TransitGatewayVpcAttachment?: TransitGatewayVpcAttachment;
-}
-export declare namespace CreateTransitGatewayVpcAttachmentResult {
-    
-    const filterSensitiveLog: (obj: CreateTransitGatewayVpcAttachmentResult) => any;
-}
-export interface CreateVolumeRequest {
-    
-    AvailabilityZone: string | undefined;
-    
-    Encrypted?: boolean;
-    
-    Iops?: number;
-    
-    KmsKeyId?: string;
-    
-    OutpostArn?: string;
-    
-    Size?: number;
-    
-    SnapshotId?: string;
-    
-    VolumeType?: VolumeType | string;
-    
-    DryRun?: boolean;
-    
-    TagSpecifications?: TagSpecification[];
-    
-    MultiAttachEnabled?: boolean;
-    
-    Throughput?: number;
-    
-    ClientToken?: string;
-}
-export declare namespace CreateVolumeRequest {
-    
-    const filterSensitiveLog: (obj: CreateVolumeRequest) => any;
-}
-export declare type VolumeState = "available" | "creating" | "deleted" | "deleting" | "error" | "in-use";
-
-export interface Volume {
-    
-    Attachments?: VolumeAttachment[];
-    
-    AvailabilityZone?: string;
-    
-    CreateTime?: Date;
-    
-    Encrypted?: boolean;
-    
-    KmsKeyId?: string;
-    
-    OutpostArn?: string;
-    
-    Size?: number;
-    
-    SnapshotId?: string;
-    
-    State?: VolumeState | string;
-    
-    VolumeId?: string;
-    
-    Iops?: number;
-    
-    Tags?: Tag[];
-    
-    VolumeType?: VolumeType | string;
-    
-    FastRestored?: boolean;
-    
-    MultiAttachEnabled?: boolean;
-    
-    Throughput?: number;
-}
-export declare namespace Volume {
-    
-    const filterSensitiveLog: (obj: Volume) => any;
-}
-export interface CreateVpcRequest {
-    
-    CidrBlock: string | undefined;
-    
-    AmazonProvidedIpv6CidrBlock?: boolean;
-    
-    Ipv6Pool?: string;
-    
-    Ipv6CidrBlock?: string;
-    
-    DryRun?: boolean;
-    
-    InstanceTenancy?: Tenancy | string;
-    
-    Ipv6CidrBlockNetworkBorderGroup?: string;
-    
-    TagSpecifications?: TagSpecification[];
-}
-export declare namespace CreateVpcRequest {
-    
-    const filterSensitiveLog: (obj: CreateVpcRequest) => any;
-}
-export interface CreateVpcResult {
-    
-    Vpc?: Vpc;
-}
-export declare namespace CreateVpcResult {
-    
-    const filterSensitiveLog: (obj: CreateVpcResult) => any;
-}
-export declare enum VpcEndpointType {
-    Gateway = "Gateway",
-    GatewayLoadBalancer = "GatewayLoadBalancer",
-    Interface = "Interface"
-}
-
-export interface CreateVpcEndpointRequest {
-    
-    DryRun?: boolean;
-    
-    VpcEndpointType?: VpcEndpointType | string;
-    
-    VpcId: string | undefined;
-    
-    ServiceName: string | undefined;
-    
-    PolicyDocument?: string;
-    
-    RouteTableIds?: string[];
-    
-    SubnetIds?: string[];
-    
-    SecurityGroupIds?: string[];
-    
-    ClientToken?: string;
-    
-    PrivateDnsEnabled?: boolean;
-    
-    TagSpecifications?: TagSpecification[];
-}
-export declare namespace CreateVpcEndpointRequest {
-    
-    const filterSensitiveLog: (obj: CreateVpcEndpointRequest) => any;
-}
-
-export interface DnsEntry {
-    
-    DnsName?: string;
-    
-    HostedZoneId?: string;
-}
-export declare namespace DnsEntry {
-    
-    const filterSensitiveLog: (obj: DnsEntry) => any;
-}
-
-export interface SecurityGroupIdentifier {
-    
-    GroupId?: string;
-    
-    GroupName?: string;
-}
-export declare namespace SecurityGroupIdentifier {
-    
-    const filterSensitiveLog: (obj: SecurityGroupIdentifier) => any;
-}
-
-export interface LastError {
-    
-    Message?: string;
-    
-    Code?: string;
-}
-export declare namespace LastError {
-    
-    const filterSensitiveLog: (obj: LastError) => any;
-}
-export declare enum State {
-    Available = "Available",
-    Deleted = "Deleted",
-    Deleting = "Deleting",
-    Expired = "Expired",
-    Failed = "Failed",
-    Pending = "Pending",
-    PendingAcceptance = "PendingAcceptance",
-    Rejected = "Rejected"
-}
-
-export interface VpcEndpoint {
-    
-    VpcEndpointId?: string;
-    
-    VpcEndpointType?: VpcEndpointType | string;
-    
-    VpcId?: string;
-    
-    ServiceName?: string;
-    
-    State?: State | string;
-    
-    PolicyDocument?: string;
-    
-    RouteTableIds?: string[];
-    
-    SubnetIds?: string[];
-    
-    Groups?: SecurityGroupIdentifier[];
-    
-    PrivateDnsEnabled?: boolean;
-    
-    RequesterManaged?: boolean;
-    
-    NetworkInterfaceIds?: string[];
-    
-    DnsEntries?: DnsEntry[];
-    
-    CreationTimestamp?: Date;
-    
-    Tags?: Tag[];
-    
-    OwnerId?: string;
-    
-    LastError?: LastError;
-}
-export declare namespace VpcEndpoint {
-    
-    const filterSensitiveLog: (obj: VpcEndpoint) => any;
-}
-
-export interface CreateVpcEndpointResult {
-    
-    VpcEndpoint?: VpcEndpoint;
-    
-    ClientToken?: string;
-}
-export declare namespace CreateVpcEndpointResult {
-    
-    const filterSensitiveLog: (obj: CreateVpcEndpointResult) => any;
-}
-export interface CreateVpcEndpointConnectionNotificationRequest {
-    
-    DryRun?: boolean;
-    
-    ServiceId?: string;
-    
-    VpcEndpointId?: string;
-    
-    ConnectionNotificationArn: string | undefined;
-    
-    ConnectionEvents: string[] | undefined;
-    
-    ClientToken?: string;
-}
-export declare namespace CreateVpcEndpointConnectionNotificationRequest {
-    
-    const filterSensitiveLog: (obj: CreateVpcEndpointConnectionNotificationRequest) => any;
-}
-export declare enum ConnectionNotificationState {
-    Disabled = "Disabled",
-    Enabled = "Enabled"
-}
-export declare enum ConnectionNotificationType {
-    Topic = "Topic"
-}
-
-export interface ConnectionNotification {
-    
-    ConnectionNotificationId?: string;
-    
-    ServiceId?: string;
-    
-    VpcEndpointId?: string;
-    
-    ConnectionNotificationType?: ConnectionNotificationType | string;
-    
-    ConnectionNotificationArn?: string;
-    
-    ConnectionEvents?: string[];
-    
-    ConnectionNotificationState?: ConnectionNotificationState | string;
-}
-export declare namespace ConnectionNotification {
-    
-    const filterSensitiveLog: (obj: ConnectionNotification) => any;
-}
-export interface CreateVpcEndpointConnectionNotificationResult {
-    
-    ConnectionNotification?: ConnectionNotification;
-    
-    ClientToken?: string;
-}
-export declare namespace CreateVpcEndpointConnectionNotificationResult {
-    
-    const filterSensitiveLog: (obj: CreateVpcEndpointConnectionNotificationResult) => any;
-}