import { _InstanceType, AcceleratorCount, AcceleratorCountRequest, AcceleratorManufacturer, AcceleratorName, AcceleratorTotalMemoryMiB, AcceleratorTotalMemoryMiBRequest, AcceleratorType, AccessScopePath, AccessScopePathRequest, AddIpamOperatingRegion, AddPrefixListEntry, AddressFamily, AttachmentStatus, CurrencyCodeValues, DnsSupportValue, FleetExcessCapacityTerminationPolicy, HostnameType, InstanceEventWindow, InternetGatewayAttachment, Ipv4PrefixSpecification, PortRange, Protocol, ReservedInstancesListing, ResourceType, RouteTableAssociationState, Subnet, Tag, TagSpecification, Tenancy, UnsuccessfulItem, WeekDay } from "./models_0";

export interface FleetLaunchTemplateSpecificationRequest {
    
    LaunchTemplateId?: string;
    
    LaunchTemplateName?: string;
    
    Version?: string;
}
export declare enum BareMetal {
    EXCLUDED = "excluded",
    INCLUDED = "included",
    REQUIRED = "required"
}

export interface BaselineEbsBandwidthMbpsRequest {
    
    Min?: number;
    
    Max?: number;
}
export declare enum BurstablePerformance {
    EXCLUDED = "excluded",
    INCLUDED = "included",
    REQUIRED = "required"
}
export declare enum CpuManufacturer {
    AMAZON_WEB_SERVICES = "amazon-web-services",
    AMD = "amd",
    INTEL = "intel"
}
export declare enum InstanceGeneration {
    CURRENT = "current",
    PREVIOUS = "previous"
}
export declare enum LocalStorage {
    EXCLUDED = "excluded",
    INCLUDED = "included",
    REQUIRED = "required"
}
export declare enum LocalStorageType {
    HDD = "hdd",
    SSD = "ssd"
}

export interface MemoryGiBPerVCpuRequest {
    
    Min?: number;
    
    Max?: number;
}

export interface MemoryMiBRequest {
    
    Min: number | undefined;
    
    Max?: number;
}

export interface NetworkInterfaceCountRequest {
    
    Min?: number;
    
    Max?: number;
}

export interface TotalLocalStorageGBRequest {
    
    Min?: number;
    
    Max?: number;
}

export interface VCpuCountRangeRequest {
    
    Min: number | undefined;
    
    Max?: number;
}

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 interface Placement {
    
    AvailabilityZone?: string;
    
    Affinity?: string;
    
    GroupName?: string;
    
    PartitionNumber?: number;
    
    HostId?: string;
    
    Tenancy?: Tenancy | string;
    
    SpreadDomain?: string;
    
    HostResourceGroupArn?: string;
}

export interface FleetLaunchTemplateOverridesRequest {
    
    InstanceType?: _InstanceType | string;
    
    MaxPrice?: string;
    
    SubnetId?: string;
    
    AvailabilityZone?: string;
    
    WeightedCapacity?: number;
    
    Priority?: number;
    
    Placement?: Placement;
    
    InstanceRequirements?: InstanceRequirementsRequest;
}

export interface FleetLaunchTemplateConfigRequest {
    
    LaunchTemplateSpecification?: FleetLaunchTemplateSpecificationRequest;
    
    Overrides?: FleetLaunchTemplateOverridesRequest[];
}
export declare enum FleetOnDemandAllocationStrategy {
    LOWEST_PRICE = "lowest-price",
    PRIORITIZED = "prioritized"
}
export declare enum FleetCapacityReservationUsageStrategy {
    USE_CAPACITY_RESERVATIONS_FIRST = "use-capacity-reservations-first"
}

export interface CapacityReservationOptionsRequest {
    
    UsageStrategy?: FleetCapacityReservationUsageStrategy | string;
}

export interface OnDemandOptionsRequest {
    
    AllocationStrategy?: FleetOnDemandAllocationStrategy | string;
    
    CapacityReservationOptions?: CapacityReservationOptionsRequest;
    
    SingleInstanceType?: boolean;
    
    SingleAvailabilityZone?: boolean;
    
    MinTargetCapacity?: number;
    
    MaxTotalPrice?: string;
}
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 interface FleetSpotMaintenanceStrategiesRequest {
    
    CapacityRebalance?: FleetSpotCapacityRebalanceRequest;
}

export interface SpotOptionsRequest {
    
    AllocationStrategy?: SpotAllocationStrategy | string;
    
    MaintenanceStrategies?: FleetSpotMaintenanceStrategiesRequest;
    
    InstanceInterruptionBehavior?: SpotInstanceInterruptionBehavior | string;
    
    InstancePoolsToUseCount?: number;
    
    SingleInstanceType?: boolean;
    
    SingleAvailabilityZone?: boolean;
    
    MinTargetCapacity?: number;
    
    MaxTotalPrice?: string;
}
export declare enum DefaultTargetCapacityType {
    ON_DEMAND = "on-demand",
    SPOT = "spot"
}
export declare enum TargetCapacityUnitType {
    MEMORY_MIB = "memory-mib",
    UNITS = "units",
    VCPU = "vcpu"
}

export interface TargetCapacitySpecificationRequest {
    
    TotalTargetCapacity: number | undefined;
    
    OnDemandTargetCapacity?: number;
    
    SpotTargetCapacity?: number;
    
    DefaultTargetCapacityType?: DefaultTargetCapacityType | string;
    
    TargetCapacityUnitType?: TargetCapacityUnitType | string;
}
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 interface FleetLaunchTemplateSpecification {
    
    LaunchTemplateId?: string;
    
    LaunchTemplateName?: string;
    
    Version?: string;
}

export interface BaselineEbsBandwidthMbps {
    
    Min?: number;
    
    Max?: number;
}

export interface MemoryGiBPerVCpu {
    
    Min?: number;
    
    Max?: number;
}

export interface MemoryMiB {
    
    Min?: number;
    
    Max?: number;
}

export interface NetworkInterfaceCount {
    
    Min?: number;
    
    Max?: number;
}

export interface TotalLocalStorageGB {
    
    Min?: number;
    
    Max?: number;
}

export interface VCpuCountRange {
    
    Min?: number;
    
    Max?: number;
}

export interface InstanceRequirements {
    
    VCpuCount?: VCpuCountRange;
    
    MemoryMiB?: MemoryMiB;
    
    CpuManufacturers?: (CpuManufacturer | string)[];
    
    MemoryGiBPerVCpu?: MemoryGiBPerVCpu;
    
    ExcludedInstanceTypes?: string[];
    
    InstanceGenerations?: (InstanceGeneration | string)[];
    
    SpotMaxPricePercentageOverLowestPrice?: number;
    
    OnDemandMaxPricePercentageOverLowestPrice?: number;
    
    BareMetal?: BareMetal | string;
    
    BurstablePerformance?: BurstablePerformance | string;
    
    RequireHibernateSupport?: boolean;
    
    NetworkInterfaceCount?: NetworkInterfaceCount;
    
    LocalStorage?: LocalStorage | string;
    
    LocalStorageTypes?: (LocalStorageType | string)[];
    
    TotalLocalStorageGB?: TotalLocalStorageGB;
    
    BaselineEbsBandwidthMbps?: BaselineEbsBandwidthMbps;
    
    AcceleratorTypes?: (AcceleratorType | string)[];
    
    AcceleratorCount?: AcceleratorCount;
    
    AcceleratorManufacturers?: (AcceleratorManufacturer | string)[];
    
    AcceleratorNames?: (AcceleratorName | string)[];
    
    AcceleratorTotalMemoryMiB?: AcceleratorTotalMemoryMiB;
}

export interface PlacementResponse {
    
    GroupName?: string;
}

export interface FleetLaunchTemplateOverrides {
    
    InstanceType?: _InstanceType | string;
    
    MaxPrice?: string;
    
    SubnetId?: string;
    
    AvailabilityZone?: string;
    
    WeightedCapacity?: number;
    
    Priority?: number;
    
    Placement?: PlacementResponse;
    
    InstanceRequirements?: InstanceRequirements;
}

export interface LaunchTemplateAndOverridesResponse {
    
    LaunchTemplateSpecification?: FleetLaunchTemplateSpecification;
    
    Overrides?: FleetLaunchTemplateOverrides;
}
export declare enum InstanceLifecycle {
    ON_DEMAND = "on-demand",
    SPOT = "spot"
}

export interface CreateFleetError {
    
    LaunchTemplateAndOverrides?: LaunchTemplateAndOverridesResponse;
    
    Lifecycle?: InstanceLifecycle | string;
    
    ErrorCode?: string;
    
    ErrorMessage?: string;
}
export declare type PlatformValues = "Windows";

export interface CreateFleetInstance {
    
    LaunchTemplateAndOverrides?: LaunchTemplateAndOverridesResponse;
    
    Lifecycle?: InstanceLifecycle | string;
    
    InstanceIds?: string[];
    
    InstanceType?: _InstanceType | string;
    
    Platform?: PlatformValues | string;
}
export interface CreateFleetResult {
    
    FleetId?: string;
    
    Errors?: CreateFleetError[];
    
    Instances?: CreateFleetInstance[];
}
export declare enum DestinationFileFormat {
    parquet = "parquet",
    plain_text = "plain-text"
}

export interface DestinationOptionsRequest {
    
    FileFormat?: DestinationFileFormat | string;
    
    HiveCompatiblePartitions?: boolean;
    
    PerHourPartition?: boolean;
}
export declare type LogDestinationType = "cloud-watch-logs" | "s3";
export declare type FlowLogsResourceType = "NetworkInterface" | "Subnet" | "TransitGateway" | "TransitGatewayAttachment" | "VPC";
export declare type TrafficType = "ACCEPT" | "ALL" | "REJECT";
export interface CreateFlowLogsRequest {
    
    DryRun?: boolean;
    
    ClientToken?: string;
    
    DeliverLogsPermissionArn?: string;
    
    LogGroupName?: string;
    
    ResourceIds: string[] | undefined;
    
    ResourceType: FlowLogsResourceType | string | undefined;
    
    TrafficType?: TrafficType | string;
    
    LogDestinationType?: LogDestinationType | string;
    
    LogDestination?: string;
    
    LogFormat?: string;
    
    TagSpecifications?: TagSpecification[];
    
    MaxAggregationInterval?: number;
    
    DestinationOptions?: DestinationOptionsRequest;
}
export interface CreateFlowLogsResult {
    
    ClientToken?: string;
    
    FlowLogIds?: string[];
    
    Unsuccessful?: UnsuccessfulItem[];
}

export interface StorageLocation {
    
    Bucket?: string;
    
    Key?: string;
}
export interface CreateFpgaImageRequest {
    
    DryRun?: boolean;
    
    InputStorageLocation: StorageLocation | undefined;
    
    LogsStorageLocation?: StorageLocation;
    
    Description?: string;
    
    Name?: string;
    
    ClientToken?: string;
    
    TagSpecifications?: TagSpecification[];
}
export interface CreateFpgaImageResult {
    
    FpgaImageId?: string;
    
    FpgaImageGlobalId?: string;
}
export declare type VolumeType = "gp2" | "gp3" | "io1" | "io2" | "sc1" | "st1" | "standard";

export interface EbsBlockDevice {
    
    DeleteOnTermination?: boolean;
    
    Iops?: number;
    
    SnapshotId?: string;
    
    VolumeSize?: number;
    
    VolumeType?: VolumeType | string;
    
    KmsKeyId?: string;
    
    Throughput?: number;
    
    OutpostArn?: string;
    
    Encrypted?: boolean;
}

export interface BlockDeviceMapping {
    
    DeviceName?: string;
    
    VirtualName?: string;
    
    Ebs?: EbsBlockDevice;
    
    NoDevice?: string;
}
export interface CreateImageRequest {
    
    BlockDeviceMappings?: BlockDeviceMapping[];
    
    Description?: string;
    
    DryRun?: boolean;
    
    InstanceId: string | undefined;
    
    Name: string | undefined;
    
    NoReboot?: boolean;
    
    TagSpecifications?: TagSpecification[];
}
export interface CreateImageResult {
    
    ImageId?: string;
}

export interface InstanceEventWindowTimeRangeRequest {
    
    StartWeekDay?: WeekDay | string;
    
    StartHour?: number;
    
    EndWeekDay?: WeekDay | string;
    
    EndHour?: number;
}
export interface CreateInstanceEventWindowRequest {
    
    DryRun?: boolean;
    
    Name?: string;
    
    TimeRanges?: InstanceEventWindowTimeRangeRequest[];
    
    CronExpression?: string;
    
    TagSpecifications?: TagSpecification[];
}
export interface CreateInstanceEventWindowResult {
    
    InstanceEventWindow?: InstanceEventWindow;
}
export declare type ContainerFormat = "ova";
export declare type DiskImageFormat = "RAW" | "VHD" | "VMDK";

export interface ExportToS3TaskSpecification {
    
    ContainerFormat?: ContainerFormat | string;
    
    DiskImageFormat?: DiskImageFormat | string;
    
    S3Bucket?: string;
    
    S3Prefix?: string;
}
export declare type ExportEnvironment = "citrix" | "microsoft" | "vmware";
export interface CreateInstanceExportTaskRequest {
    
    Description?: string;
    
    ExportToS3Task: ExportToS3TaskSpecification | undefined;
    
    InstanceId: string | undefined;
    
    TargetEnvironment: ExportEnvironment | string | undefined;
    
    TagSpecifications?: TagSpecification[];
}

export interface ExportToS3Task {
    
    ContainerFormat?: ContainerFormat | string;
    
    DiskImageFormat?: DiskImageFormat | string;
    
    S3Bucket?: string;
    
    S3Key?: string;
}

export interface InstanceExportDetails {
    
    InstanceId?: string;
    
    TargetEnvironment?: ExportEnvironment | string;
}
export declare type ExportTaskState = "active" | "cancelled" | "cancelling" | "completed";

export interface ExportTask {
    
    Description?: string;
    
    ExportTaskId?: string;
    
    ExportToS3Task?: ExportToS3Task;
    
    InstanceExportDetails?: InstanceExportDetails;
    
    State?: ExportTaskState | string;
    
    StatusMessage?: string;
    
    Tags?: Tag[];
}
export interface CreateInstanceExportTaskResult {
    
    ExportTask?: ExportTask;
}
export interface CreateInternetGatewayRequest {
    
    TagSpecifications?: TagSpecification[];
    
    DryRun?: boolean;
}

export interface InternetGateway {
    
    Attachments?: InternetGatewayAttachment[];
    
    InternetGatewayId?: string;
    
    OwnerId?: string;
    
    Tags?: Tag[];
}
export interface CreateInternetGatewayResult {
    
    InternetGateway?: InternetGateway;
}
export interface CreateIpamRequest {
    
    DryRun?: boolean;
    
    Description?: string;
    
    OperatingRegions?: AddIpamOperatingRegion[];
    
    TagSpecifications?: TagSpecification[];
    
    ClientToken?: string;
}

export interface IpamOperatingRegion {
    
    RegionName?: string;
}
export declare enum IpamState {
    create_complete = "create-complete",
    create_failed = "create-failed",
    create_in_progress = "create-in-progress",
    delete_complete = "delete-complete",
    delete_failed = "delete-failed",
    delete_in_progress = "delete-in-progress",
    isolate_complete = "isolate-complete",
    isolate_in_progress = "isolate-in-progress",
    modify_complete = "modify-complete",
    modify_failed = "modify-failed",
    modify_in_progress = "modify-in-progress",
    restore_in_progress = "restore-in-progress"
}

export interface Ipam {
    
    OwnerId?: string;
    
    IpamId?: string;
    
    IpamArn?: string;
    
    IpamRegion?: string;
    
    PublicDefaultScopeId?: string;
    
    PrivateDefaultScopeId?: string;
    
    ScopeCount?: number;
    
    Description?: string;
    
    OperatingRegions?: IpamOperatingRegion[];
    
    State?: IpamState | string;
    
    Tags?: Tag[];
}
export interface CreateIpamResult {
    
    Ipam?: Ipam;
}

export interface RequestIpamResourceTag {
    
    Key?: string;
    
    Value?: string;
}
export declare enum IpamPoolAwsService {
    ec2 = "ec2"
}
export interface CreateIpamPoolRequest {
    
    DryRun?: boolean;
    
    IpamScopeId: string | undefined;
    
    Locale?: string;
    
    SourceIpamPoolId?: string;
    
    Description?: string;
    
    AddressFamily: AddressFamily | string | undefined;
    
    AutoImport?: boolean;
    
    PubliclyAdvertisable?: boolean;
    
    AllocationMinNetmaskLength?: number;
    
    AllocationMaxNetmaskLength?: number;
    
    AllocationDefaultNetmaskLength?: number;
    
    AllocationResourceTags?: RequestIpamResourceTag[];
    
    TagSpecifications?: TagSpecification[];
    
    ClientToken?: string;
    
    AwsService?: IpamPoolAwsService | string;
}

export interface IpamResourceTag {
    
    Key?: string;
    
    Value?: string;
}
export declare enum IpamScopeType {
    private = "private",
    public = "public"
}
export declare enum IpamPoolState {
    create_complete = "create-complete",
    create_failed = "create-failed",
    create_in_progress = "create-in-progress",
    delete_complete = "delete-complete",
    delete_failed = "delete-failed",
    delete_in_progress = "delete-in-progress",
    isolate_complete = "isolate-complete",
    isolate_in_progress = "isolate-in-progress",
    modify_complete = "modify-complete",
    modify_failed = "modify-failed",
    modify_in_progress = "modify-in-progress",
    restore_in_progress = "restore-in-progress"
}

export 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 interface CreateIpamPoolResult {
    
    IpamPool?: IpamPool;
}
export interface CreateIpamScopeRequest {
    
    DryRun?: boolean;
    
    IpamId: string | undefined;
    
    Description?: string;
    
    TagSpecifications?: TagSpecification[];
    
    ClientToken?: string;
}
export declare enum IpamScopeState {
    create_complete = "create-complete",
    create_failed = "create-failed",
    create_in_progress = "create-in-progress",
    delete_complete = "delete-complete",
    delete_failed = "delete-failed",
    delete_in_progress = "delete-in-progress",
    isolate_complete = "isolate-complete",
    isolate_in_progress = "isolate-in-progress",
    modify_complete = "modify-complete",
    modify_failed = "modify-failed",
    modify_in_progress = "modify-in-progress",
    restore_in_progress = "restore-in-progress"
}

export 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 interface CreateIpamScopeResult {
    
    IpamScope?: IpamScope;
}
export declare enum KeyFormat {
    pem = "pem",
    ppk = "ppk"
}
export declare enum KeyType {
    ed25519 = "ed25519",
    rsa = "rsa"
}
export interface CreateKeyPairRequest {
    
    KeyName: string | undefined;
    
    DryRun?: boolean;
    
    KeyType?: KeyType | string;
    
    TagSpecifications?: TagSpecification[];
    
    KeyFormat?: KeyFormat | string;
}

export interface KeyPair {
    
    KeyFingerprint?: string;
    
    KeyMaterial?: string;
    
    KeyName?: string;
    
    KeyPairId?: string;
    
    Tags?: Tag[];
}

export interface LaunchTemplateEbsBlockDeviceRequest {
    
    Encrypted?: boolean;
    
    DeleteOnTermination?: boolean;
    
    Iops?: number;
    
    KmsKeyId?: string;
    
    SnapshotId?: string;
    
    VolumeSize?: number;
    
    VolumeType?: VolumeType | string;
    
    Throughput?: number;
}

export interface LaunchTemplateBlockDeviceMappingRequest {
    
    DeviceName?: string;
    
    VirtualName?: string;
    
    Ebs?: LaunchTemplateEbsBlockDeviceRequest;
    
    NoDevice?: string;
}
export declare type CapacityReservationPreference = "none" | "open";

export interface CapacityReservationTarget {
    
    CapacityReservationId?: string;
    
    CapacityReservationResourceGroupArn?: string;
}

export interface LaunchTemplateCapacityReservationSpecificationRequest {
    
    CapacityReservationPreference?: CapacityReservationPreference | string;
    
    CapacityReservationTarget?: CapacityReservationTarget;
}

export interface LaunchTemplateCpuOptionsRequest {
    
    CoreCount?: number;
    
    ThreadsPerCore?: number;
}

export interface CreditSpecificationRequest {
    
    CpuCredits: string | undefined;
}

export interface ElasticGpuSpecification {
    
    Type: string | undefined;
}

export interface LaunchTemplateElasticInferenceAccelerator {
    
    Type: string | undefined;
    
    Count?: number;
}

export interface LaunchTemplateEnclaveOptionsRequest {
    
    Enabled?: boolean;
}

export interface LaunchTemplateHibernationOptionsRequest {
    
    Configured?: boolean;
}

export interface LaunchTemplateIamInstanceProfileSpecificationRequest {
    
    Arn?: string;
    
    Name?: string;
}
export declare type ShutdownBehavior = "stop" | "terminate";
export declare type MarketType = "spot";
export declare type InstanceInterruptionBehavior = "hibernate" | "stop" | "terminate";
export declare type SpotInstanceType = "one-time" | "persistent";

export interface LaunchTemplateSpotMarketOptionsRequest {
    
    MaxPrice?: string;
    
    SpotInstanceType?: SpotInstanceType | string;
    
    BlockDurationMinutes?: number;
    
    ValidUntil?: Date;
    
    InstanceInterruptionBehavior?: InstanceInterruptionBehavior | string;
}

export interface LaunchTemplateInstanceMarketOptionsRequest {
    
    MarketType?: MarketType | string;
    
    SpotOptions?: LaunchTemplateSpotMarketOptionsRequest;
}

export interface LaunchTemplateLicenseConfigurationRequest {
    
    LicenseConfigurationArn?: string;
}
export declare enum LaunchTemplateAutoRecoveryState {
    default = "default",
    disabled = "disabled"
}

export interface LaunchTemplateInstanceMaintenanceOptionsRequest {
    
    AutoRecovery?: LaunchTemplateAutoRecoveryState | string;
}
export declare type LaunchTemplateInstanceMetadataEndpointState = "disabled" | "enabled";
export declare enum LaunchTemplateInstanceMetadataProtocolIpv6 {
    disabled = "disabled",
    enabled = "enabled"
}
export declare enum LaunchTemplateHttpTokensState {
    optional = "optional",
    required = "required"
}
export declare enum LaunchTemplateInstanceMetadataTagsState {
    disabled = "disabled",
    enabled = "enabled"
}

export interface LaunchTemplateInstanceMetadataOptionsRequest {
    
    HttpTokens?: LaunchTemplateHttpTokensState | string;
    
    HttpPutResponseHopLimit?: number;
    
    HttpEndpoint?: LaunchTemplateInstanceMetadataEndpointState | string;
    
    HttpProtocolIpv6?: LaunchTemplateInstanceMetadataProtocolIpv6 | string;
    
    InstanceMetadataTags?: LaunchTemplateInstanceMetadataTagsState | string;
}

export interface LaunchTemplatesMonitoringRequest {
    
    Enabled?: boolean;
}

export interface Ipv4PrefixSpecificationRequest {
    
    Ipv4Prefix?: string;
}

export interface InstanceIpv6AddressRequest {
    
    Ipv6Address?: string;
}

export interface Ipv6PrefixSpecificationRequest {
    
    Ipv6Prefix?: string;
}

export interface PrivateIpAddressSpecification {
    
    Primary?: boolean;
    
    PrivateIpAddress?: string;
}

export interface LaunchTemplateInstanceNetworkInterfaceSpecificationRequest {
    
    AssociateCarrierIpAddress?: boolean;
    
    AssociatePublicIpAddress?: boolean;
    
    DeleteOnTermination?: boolean;
    
    Description?: string;
    
    DeviceIndex?: number;
    
    Groups?: string[];
    
    InterfaceType?: string;
    
    Ipv6AddressCount?: number;
    
    Ipv6Addresses?: InstanceIpv6AddressRequest[];
    
    NetworkInterfaceId?: string;
    
    PrivateIpAddress?: string;
    
    PrivateIpAddresses?: PrivateIpAddressSpecification[];
    
    SecondaryPrivateIpAddressCount?: number;
    
    SubnetId?: string;
    
    NetworkCardIndex?: number;
    
    Ipv4Prefixes?: Ipv4PrefixSpecificationRequest[];
    
    Ipv4PrefixCount?: number;
    
    Ipv6Prefixes?: Ipv6PrefixSpecificationRequest[];
    
    Ipv6PrefixCount?: number;
}

export interface LaunchTemplatePlacementRequest {
    
    AvailabilityZone?: string;
    
    Affinity?: string;
    
    GroupName?: string;
    
    HostId?: string;
    
    Tenancy?: Tenancy | string;
    
    SpreadDomain?: string;
    
    HostResourceGroupArn?: string;
    
    PartitionNumber?: number;
}

export interface LaunchTemplatePrivateDnsNameOptionsRequest {
    
    HostnameType?: HostnameType | string;
    
    EnableResourceNameDnsARecord?: boolean;
    
    EnableResourceNameDnsAAAARecord?: boolean;
}

export interface LaunchTemplateTagSpecificationRequest {
    
    ResourceType?: ResourceType | string;
    
    Tags?: Tag[];
}

export interface RequestLaunchTemplateData {
    
    KernelId?: string;
    
    EbsOptimized?: boolean;
    
    IamInstanceProfile?: LaunchTemplateIamInstanceProfileSpecificationRequest;
    
    BlockDeviceMappings?: LaunchTemplateBlockDeviceMappingRequest[];
    
    NetworkInterfaces?: LaunchTemplateInstanceNetworkInterfaceSpecificationRequest[];
    
    ImageId?: string;
    
    InstanceType?: _InstanceType | string;
    
    KeyName?: string;
    
    Monitoring?: LaunchTemplatesMonitoringRequest;
    
    Placement?: LaunchTemplatePlacementRequest;
    
    RamDiskId?: string;
    
    DisableApiTermination?: boolean;
    
    InstanceInitiatedShutdownBehavior?: ShutdownBehavior | string;
    
    UserData?: string;
    
    TagSpecifications?: LaunchTemplateTagSpecificationRequest[];
    
    ElasticGpuSpecifications?: ElasticGpuSpecification[];
    
    ElasticInferenceAccelerators?: LaunchTemplateElasticInferenceAccelerator[];
    
    SecurityGroupIds?: string[];
    
    SecurityGroups?: string[];
    
    InstanceMarketOptions?: LaunchTemplateInstanceMarketOptionsRequest;
    
    CreditSpecification?: CreditSpecificationRequest;
    
    CpuOptions?: LaunchTemplateCpuOptionsRequest;
    
    CapacityReservationSpecification?: LaunchTemplateCapacityReservationSpecificationRequest;
    
    LicenseSpecifications?: LaunchTemplateLicenseConfigurationRequest[];
    
    HibernationOptions?: LaunchTemplateHibernationOptionsRequest;
    
    MetadataOptions?: LaunchTemplateInstanceMetadataOptionsRequest;
    
    EnclaveOptions?: LaunchTemplateEnclaveOptionsRequest;
    
    InstanceRequirements?: InstanceRequirementsRequest;
    
    PrivateDnsNameOptions?: LaunchTemplatePrivateDnsNameOptionsRequest;
    
    MaintenanceOptions?: LaunchTemplateInstanceMaintenanceOptionsRequest;
    
    DisableApiStop?: boolean;
}
export interface CreateLaunchTemplateRequest {
    
    DryRun?: boolean;
    
    ClientToken?: string;
    
    LaunchTemplateName: string | undefined;
    
    VersionDescription?: string;
    
    LaunchTemplateData: RequestLaunchTemplateData | undefined;
    
    TagSpecifications?: TagSpecification[];
}

export interface LaunchTemplate {
    
    LaunchTemplateId?: string;
    
    LaunchTemplateName?: string;
    
    CreateTime?: Date;
    
    CreatedBy?: string;
    
    DefaultVersionNumber?: number;
    
    LatestVersionNumber?: number;
    
    Tags?: Tag[];
}

export interface ValidationError {
    
    Code?: string;
    
    Message?: string;
}

export interface ValidationWarning {
    
    Errors?: ValidationError[];
}
export interface CreateLaunchTemplateResult {
    
    LaunchTemplate?: LaunchTemplate;
    
    Warning?: ValidationWarning;
}
export interface CreateLaunchTemplateVersionRequest {
    
    DryRun?: boolean;
    
    ClientToken?: string;
    
    LaunchTemplateId?: string;
    
    LaunchTemplateName?: string;
    
    SourceVersion?: string;
    
    VersionDescription?: string;
    
    LaunchTemplateData: RequestLaunchTemplateData | undefined;
}

export interface LaunchTemplateEbsBlockDevice {
    
    Encrypted?: boolean;
    
    DeleteOnTermination?: boolean;
    
    Iops?: number;
    
    KmsKeyId?: string;
    
    SnapshotId?: string;
    
    VolumeSize?: number;
    
    VolumeType?: VolumeType | string;
    
    Throughput?: number;
}

export interface LaunchTemplateBlockDeviceMapping {
    
    DeviceName?: string;
    
    VirtualName?: string;
    
    Ebs?: LaunchTemplateEbsBlockDevice;
    
    NoDevice?: string;
}

export interface CapacityReservationTargetResponse {
    
    CapacityReservationId?: string;
    
    CapacityReservationResourceGroupArn?: string;
}

export interface LaunchTemplateCapacityReservationSpecificationResponse {
    
    CapacityReservationPreference?: CapacityReservationPreference | string;
    
    CapacityReservationTarget?: CapacityReservationTargetResponse;
}

export interface LaunchTemplateCpuOptions {
    
    CoreCount?: number;
    
    ThreadsPerCore?: number;
}

export interface CreditSpecification {
    
    CpuCredits?: string;
}

export interface ElasticGpuSpecificationResponse {
    
    Type?: string;
}

export interface LaunchTemplateElasticInferenceAcceleratorResponse {
    
    Type?: string;
    
    Count?: number;
}

export interface LaunchTemplateEnclaveOptions {
    
    Enabled?: boolean;
}

export interface LaunchTemplateHibernationOptions {
    
    Configured?: boolean;
}

export interface LaunchTemplateIamInstanceProfileSpecification {
    
    Arn?: string;
    
    Name?: string;
}

export interface LaunchTemplateSpotMarketOptions {
    
    MaxPrice?: string;
    
    SpotInstanceType?: SpotInstanceType | string;
    
    BlockDurationMinutes?: number;
    
    ValidUntil?: Date;
    
    InstanceInterruptionBehavior?: InstanceInterruptionBehavior | string;
}

export interface LaunchTemplateInstanceMarketOptions {
    
    MarketType?: MarketType | string;
    
    SpotOptions?: LaunchTemplateSpotMarketOptions;
}

export interface LaunchTemplateLicenseConfiguration {
    
    LicenseConfigurationArn?: string;
}

export interface LaunchTemplateInstanceMaintenanceOptions {
    
    AutoRecovery?: LaunchTemplateAutoRecoveryState | string;
}
export declare type LaunchTemplateInstanceMetadataOptionsState = "applied" | "pending";

export interface LaunchTemplateInstanceMetadataOptions {
    
    State?: LaunchTemplateInstanceMetadataOptionsState | string;
    
    HttpTokens?: LaunchTemplateHttpTokensState | string;
    
    HttpPutResponseHopLimit?: number;
    
    HttpEndpoint?: LaunchTemplateInstanceMetadataEndpointState | string;
    
    HttpProtocolIpv6?: LaunchTemplateInstanceMetadataProtocolIpv6 | string;
    
    InstanceMetadataTags?: LaunchTemplateInstanceMetadataTagsState | string;
}

export interface LaunchTemplatesMonitoring {
    
    Enabled?: boolean;
}

export interface Ipv4PrefixSpecificationResponse {
    
    Ipv4Prefix?: string;
}

export interface InstanceIpv6Address {
    
    Ipv6Address?: string;
}

export interface Ipv6PrefixSpecificationResponse {
    
    Ipv6Prefix?: string;
}

export interface LaunchTemplateInstanceNetworkInterfaceSpecification {
    
    AssociateCarrierIpAddress?: boolean;
    
    AssociatePublicIpAddress?: boolean;
    
    DeleteOnTermination?: boolean;
    
    Description?: string;
    
    DeviceIndex?: number;
    
    Groups?: string[];
    
    InterfaceType?: string;
    
    Ipv6AddressCount?: number;
    
    Ipv6Addresses?: InstanceIpv6Address[];
    
    NetworkInterfaceId?: string;
    
    PrivateIpAddress?: string;
    
    PrivateIpAddresses?: PrivateIpAddressSpecification[];
    
    SecondaryPrivateIpAddressCount?: number;
    
    SubnetId?: string;
    
    NetworkCardIndex?: number;
    
    Ipv4Prefixes?: Ipv4PrefixSpecificationResponse[];
    
    Ipv4PrefixCount?: number;
    
    Ipv6Prefixes?: Ipv6PrefixSpecificationResponse[];
    
    Ipv6PrefixCount?: number;
}

export interface LaunchTemplatePlacement {
    
    AvailabilityZone?: string;
    
    Affinity?: string;
    
    GroupName?: string;
    
    HostId?: string;
    
    Tenancy?: Tenancy | string;
    
    SpreadDomain?: string;
    
    HostResourceGroupArn?: string;
    
    PartitionNumber?: number;
}

export interface LaunchTemplatePrivateDnsNameOptions {
    
    HostnameType?: HostnameType | string;
    
    EnableResourceNameDnsARecord?: boolean;
    
    EnableResourceNameDnsAAAARecord?: boolean;
}

export interface LaunchTemplateTagSpecification {
    
    ResourceType?: ResourceType | string;
    
    Tags?: Tag[];
}

export interface ResponseLaunchTemplateData {
    
    KernelId?: string;
    
    EbsOptimized?: boolean;
    
    IamInstanceProfile?: LaunchTemplateIamInstanceProfileSpecification;
    
    BlockDeviceMappings?: LaunchTemplateBlockDeviceMapping[];
    
    NetworkInterfaces?: LaunchTemplateInstanceNetworkInterfaceSpecification[];
    
    ImageId?: string;
    
    InstanceType?: _InstanceType | string;
    
    KeyName?: string;
    
    Monitoring?: LaunchTemplatesMonitoring;
    
    Placement?: LaunchTemplatePlacement;
    
    RamDiskId?: string;
    
    DisableApiTermination?: boolean;
    
    InstanceInitiatedShutdownBehavior?: ShutdownBehavior | string;
    
    UserData?: string;
    
    TagSpecifications?: LaunchTemplateTagSpecification[];
    
    ElasticGpuSpecifications?: ElasticGpuSpecificationResponse[];
    
    ElasticInferenceAccelerators?: LaunchTemplateElasticInferenceAcceleratorResponse[];
    
    SecurityGroupIds?: string[];
    
    SecurityGroups?: string[];
    
    InstanceMarketOptions?: LaunchTemplateInstanceMarketOptions;
    
    CreditSpecification?: CreditSpecification;
    
    CpuOptions?: LaunchTemplateCpuOptions;
    
    CapacityReservationSpecification?: LaunchTemplateCapacityReservationSpecificationResponse;
    
    LicenseSpecifications?: LaunchTemplateLicenseConfiguration[];
    
    HibernationOptions?: LaunchTemplateHibernationOptions;
    
    MetadataOptions?: LaunchTemplateInstanceMetadataOptions;
    
    EnclaveOptions?: LaunchTemplateEnclaveOptions;
    
    InstanceRequirements?: InstanceRequirements;
    
    PrivateDnsNameOptions?: LaunchTemplatePrivateDnsNameOptions;
    
    MaintenanceOptions?: LaunchTemplateInstanceMaintenanceOptions;
    
    DisableApiStop?: boolean;
}

export interface LaunchTemplateVersion {
    
    LaunchTemplateId?: string;
    
    LaunchTemplateName?: string;
    
    VersionNumber?: number;
    
    VersionDescription?: string;
    
    CreateTime?: Date;
    
    CreatedBy?: string;
    
    DefaultVersion?: boolean;
    
    LaunchTemplateData?: ResponseLaunchTemplateData;
}
export interface CreateLaunchTemplateVersionResult {
    
    LaunchTemplateVersion?: LaunchTemplateVersion;
    
    Warning?: ValidationWarning;
}
export interface CreateLocalGatewayRouteRequest {
    
    DestinationCidrBlock: string | undefined;
    
    LocalGatewayRouteTableId: string | undefined;
    
    LocalGatewayVirtualInterfaceGroupId: string | undefined;
    
    DryRun?: boolean;
}
export declare type LocalGatewayRouteState = "active" | "blackhole" | "deleted" | "deleting" | "pending";
export declare type LocalGatewayRouteType = "propagated" | "static";

export interface LocalGatewayRoute {
    
    DestinationCidrBlock?: string;
    
    LocalGatewayVirtualInterfaceGroupId?: string;
    
    Type?: LocalGatewayRouteType | string;
    
    State?: LocalGatewayRouteState | string;
    
    LocalGatewayRouteTableId?: string;
    
    LocalGatewayRouteTableArn?: string;
    
    OwnerId?: string;
}
export interface CreateLocalGatewayRouteResult {
    
    Route?: LocalGatewayRoute;
}
export interface CreateLocalGatewayRouteTableVpcAssociationRequest {
    
    LocalGatewayRouteTableId: string | undefined;
    
    VpcId: string | undefined;
    
    TagSpecifications?: TagSpecification[];
    
    DryRun?: boolean;
}

export interface LocalGatewayRouteTableVpcAssociation {
    
    LocalGatewayRouteTableVpcAssociationId?: string;
    
    LocalGatewayRouteTableId?: string;
    
    LocalGatewayRouteTableArn?: string;
    
    LocalGatewayId?: string;
    
    VpcId?: string;
    
    OwnerId?: string;
    
    State?: string;
    
    Tags?: Tag[];
}
export interface CreateLocalGatewayRouteTableVpcAssociationResult {
    
    LocalGatewayRouteTableVpcAssociation?: LocalGatewayRouteTableVpcAssociation;
}
export interface CreateManagedPrefixListRequest {
    
    DryRun?: boolean;
    
    PrefixListName: string | undefined;
    
    Entries?: AddPrefixListEntry[];
    
    MaxEntries: number | undefined;
    
    TagSpecifications?: TagSpecification[];
    
    AddressFamily: string | undefined;
    
    ClientToken?: string;
}
export declare type PrefixListState = "create-complete" | "create-failed" | "create-in-progress" | "delete-complete" | "delete-failed" | "delete-in-progress" | "modify-complete" | "modify-failed" | "modify-in-progress" | "restore-complete" | "restore-failed" | "restore-in-progress";

export interface ManagedPrefixList {
    
    PrefixListId?: string;
    
    AddressFamily?: string;
    
    State?: PrefixListState | string;
    
    StateMessage?: string;
    
    PrefixListArn?: string;
    
    PrefixListName?: string;
    
    MaxEntries?: number;
    
    Version?: number;
    
    Tags?: Tag[];
    
    OwnerId?: string;
}
export interface CreateManagedPrefixListResult {
    
    PrefixList?: ManagedPrefixList;
}
export declare enum ConnectivityType {
    PRIVATE = "private",
    PUBLIC = "public"
}
export interface CreateNatGatewayRequest {
    
    AllocationId?: string;
    
    ClientToken?: string;
    
    DryRun?: boolean;
    
    SubnetId: string | undefined;
    
    TagSpecifications?: TagSpecification[];
    
    ConnectivityType?: ConnectivityType | string;
}

export interface NatGatewayAddress {
    
    AllocationId?: string;
    
    NetworkInterfaceId?: string;
    
    PrivateIp?: string;
    
    PublicIp?: string;
}

export interface ProvisionedBandwidth {
    
    ProvisionTime?: Date;
    
    Provisioned?: string;
    
    RequestTime?: Date;
    
    Requested?: string;
    
    Status?: string;
}
export declare enum NatGatewayState {
    AVAILABLE = "available",
    DELETED = "deleted",
    DELETING = "deleting",
    FAILED = "failed",
    PENDING = "pending"
}

export interface NatGateway {
    
    CreateTime?: Date;
    
    DeleteTime?: Date;
    
    FailureCode?: string;
    
    FailureMessage?: string;
    
    NatGatewayAddresses?: NatGatewayAddress[];
    
    NatGatewayId?: string;
    
    ProvisionedBandwidth?: ProvisionedBandwidth;
    
    State?: NatGatewayState | string;
    
    SubnetId?: string;
    
    VpcId?: string;
    
    Tags?: Tag[];
    
    ConnectivityType?: ConnectivityType | string;
}
export interface CreateNatGatewayResult {
    
    ClientToken?: string;
    
    NatGateway?: NatGateway;
}
export interface CreateNetworkAclRequest {
    
    DryRun?: boolean;
    
    VpcId: string | undefined;
    
    TagSpecifications?: TagSpecification[];
}

export interface NetworkAclAssociation {
    
    NetworkAclAssociationId?: string;
    
    NetworkAclId?: string;
    
    SubnetId?: string;
}

export interface IcmpTypeCode {
    
    Code?: number;
    
    Type?: number;
}
export declare type RuleAction = "allow" | "deny";

export interface NetworkAclEntry {
    
    CidrBlock?: string;
    
    Egress?: boolean;
    
    IcmpTypeCode?: IcmpTypeCode;
    
    Ipv6CidrBlock?: string;
    
    PortRange?: PortRange;
    
    Protocol?: string;
    
    RuleAction?: RuleAction | string;
    
    RuleNumber?: number;
}

export interface NetworkAcl {
    
    Associations?: NetworkAclAssociation[];
    
    Entries?: NetworkAclEntry[];
    
    IsDefault?: boolean;
    
    NetworkAclId?: string;
    
    Tags?: Tag[];
    
    VpcId?: string;
    
    OwnerId?: string;
}
export interface CreateNetworkAclResult {
    
    NetworkAcl?: NetworkAcl;
}
export interface CreateNetworkAclEntryRequest {
    
    CidrBlock?: string;
    
    DryRun?: boolean;
    
    Egress: boolean | undefined;
    
    IcmpTypeCode?: IcmpTypeCode;
    
    Ipv6CidrBlock?: string;
    
    NetworkAclId: string | undefined;
    
    PortRange?: PortRange;
    
    Protocol: string | undefined;
    
    RuleAction: RuleAction | string | undefined;
    
    RuleNumber: number | undefined;
}
export interface CreateNetworkInsightsAccessScopeRequest {
    
    MatchPaths?: AccessScopePathRequest[];
    
    ExcludePaths?: AccessScopePathRequest[];
    
    ClientToken?: string;
    
    TagSpecifications?: TagSpecification[];
    
    DryRun?: boolean;
}

export interface NetworkInsightsAccessScope {
    
    NetworkInsightsAccessScopeId?: string;
    
    NetworkInsightsAccessScopeArn?: string;
    
    CreatedDate?: Date;
    
    UpdatedDate?: Date;
    
    Tags?: Tag[];
}

export interface NetworkInsightsAccessScopeContent {
    
    NetworkInsightsAccessScopeId?: string;
    
    MatchPaths?: AccessScopePath[];
    
    ExcludePaths?: AccessScopePath[];
}
export interface CreateNetworkInsightsAccessScopeResult {
    
    NetworkInsightsAccessScope?: NetworkInsightsAccessScope;
    
    NetworkInsightsAccessScopeContent?: NetworkInsightsAccessScopeContent;
}
export interface CreateNetworkInsightsPathRequest {
    
    SourceIp?: string;
    
    DestinationIp?: string;
    
    Source: string | undefined;
    
    Destination: string | undefined;
    
    Protocol: Protocol | string | undefined;
    
    DestinationPort?: number;
    
    TagSpecifications?: TagSpecification[];
    
    DryRun?: boolean;
    
    ClientToken?: string;
}

export interface NetworkInsightsPath {
    
    NetworkInsightsPathId?: string;
    
    NetworkInsightsPathArn?: string;
    
    CreatedDate?: Date;
    
    Source?: string;
    
    Destination?: string;
    
    SourceIp?: string;
    
    DestinationIp?: string;
    
    Protocol?: Protocol | string;
    
    DestinationPort?: number;
    
    Tags?: Tag[];
}
export interface CreateNetworkInsightsPathResult {
    
    NetworkInsightsPath?: NetworkInsightsPath;
}
export declare type NetworkInterfaceCreationType = "branch" | "efa" | "trunk";

export interface CreateNetworkInterfaceRequest {
    
    Description?: string;
    
    DryRun?: boolean;
    
    Groups?: string[];
    
    Ipv6AddressCount?: number;
    
    Ipv6Addresses?: InstanceIpv6Address[];
    
    PrivateIpAddress?: string;
    
    PrivateIpAddresses?: PrivateIpAddressSpecification[];
    
    SecondaryPrivateIpAddressCount?: number;
    
    Ipv4Prefixes?: Ipv4PrefixSpecificationRequest[];
    
    Ipv4PrefixCount?: number;
    
    Ipv6Prefixes?: Ipv6PrefixSpecificationRequest[];
    
    Ipv6PrefixCount?: number;
    
    InterfaceType?: NetworkInterfaceCreationType | string;
    
    SubnetId: string | undefined;
    
    TagSpecifications?: TagSpecification[];
    
    ClientToken?: string;
}

export interface NetworkInterfaceAssociation {
    
    AllocationId?: string;
    
    AssociationId?: string;
    
    IpOwnerId?: string;
    
    PublicDnsName?: string;
    
    PublicIp?: string;
    
    CustomerOwnedIp?: string;
    
    CarrierIp?: string;
}

export interface NetworkInterfaceAttachment {
    
    AttachTime?: Date;
    
    AttachmentId?: string;
    
    DeleteOnTermination?: boolean;
    
    DeviceIndex?: number;
    
    NetworkCardIndex?: number;
    
    InstanceId?: string;
    
    InstanceOwnerId?: string;
    
    Status?: AttachmentStatus | string;
}

export interface GroupIdentifier {
    
    GroupName?: string;
    
    GroupId?: string;
}
export declare type NetworkInterfaceType = "api_gateway_managed" | "aws_codestar_connections_managed" | "branch" | "efa" | "gateway_load_balancer" | "gateway_load_balancer_endpoint" | "global_accelerator_managed" | "interface" | "iot_rules_managed" | "lambda" | "load_balancer" | "natGateway" | "network_load_balancer" | "quicksight" | "transit_gateway" | "trunk" | "vpc_endpoint";

export interface NetworkInterfaceIpv6Address {
    
    Ipv6Address?: string;
}

export interface Ipv6PrefixSpecification {
    
    Ipv6Prefix?: string;
}

export interface NetworkInterfacePrivateIpAddress {
    
    Association?: NetworkInterfaceAssociation;
    
    Primary?: boolean;
    
    PrivateDnsName?: string;
    
    PrivateIpAddress?: string;
}
export declare type NetworkInterfaceStatus = "associated" | "attaching" | "available" | "detaching" | "in-use";

export interface NetworkInterface {
    
    Association?: NetworkInterfaceAssociation;
    
    Attachment?: NetworkInterfaceAttachment;
    
    AvailabilityZone?: string;
    
    Description?: string;
    
    Groups?: GroupIdentifier[];
    
    InterfaceType?: NetworkInterfaceType | string;
    
    Ipv6Addresses?: NetworkInterfaceIpv6Address[];
    
    MacAddress?: string;
    
    NetworkInterfaceId?: string;
    
    OutpostArn?: string;
    
    OwnerId?: string;
    
    PrivateDnsName?: string;
    
    PrivateIpAddress?: string;
    
    PrivateIpAddresses?: NetworkInterfacePrivateIpAddress[];
    
    Ipv4Prefixes?: Ipv4PrefixSpecification[];
    
    Ipv6Prefixes?: Ipv6PrefixSpecification[];
    
    RequesterId?: string;
    
    RequesterManaged?: boolean;
    
    SourceDestCheck?: boolean;
    
    Status?: NetworkInterfaceStatus | string;
    
    SubnetId?: string;
    
    TagSet?: Tag[];
    
    VpcId?: string;
    
    DenyAllIgwTraffic?: boolean;
    
    Ipv6Native?: boolean;
    
    Ipv6Address?: string;
}

export interface CreateNetworkInterfaceResult {
    
    NetworkInterface?: NetworkInterface;
    
    ClientToken?: string;
}
export declare type InterfacePermissionType = "EIP-ASSOCIATE" | "INSTANCE-ATTACH";

export interface CreateNetworkInterfacePermissionRequest {
    
    NetworkInterfaceId: string | undefined;
    
    AwsAccountId?: string;
    
    AwsService?: string;
    
    Permission: InterfacePermissionType | string | undefined;
    
    DryRun?: boolean;
}
export declare type NetworkInterfacePermissionStateCode = "granted" | "pending" | "revoked" | "revoking";

export interface NetworkInterfacePermissionState {
    
    State?: NetworkInterfacePermissionStateCode | string;
    
    StatusMessage?: string;
}

export interface NetworkInterfacePermission {
    
    NetworkInterfacePermissionId?: string;
    
    NetworkInterfaceId?: string;
    
    AwsAccountId?: string;
    
    AwsService?: string;
    
    Permission?: InterfacePermissionType | string;
    
    PermissionState?: NetworkInterfacePermissionState;
}

export interface CreateNetworkInterfacePermissionResult {
    
    InterfacePermission?: NetworkInterfacePermission;
}
export declare enum SpreadLevel {
    host = "host",
    rack = "rack"
}
export declare type PlacementStrategy = "cluster" | "partition" | "spread";
export interface CreatePlacementGroupRequest {
    
    DryRun?: boolean;
    
    GroupName?: string;
    
    Strategy?: PlacementStrategy | string;
    
    PartitionCount?: number;
    
    TagSpecifications?: TagSpecification[];
    
    SpreadLevel?: SpreadLevel | string;
}
export declare type PlacementGroupState = "available" | "deleted" | "deleting" | "pending";

export interface PlacementGroup {
    
    GroupName?: string;
    
    State?: PlacementGroupState | string;
    
    Strategy?: PlacementStrategy | string;
    
    PartitionCount?: number;
    
    GroupId?: string;
    
    Tags?: Tag[];
    
    GroupArn?: string;
    
    SpreadLevel?: SpreadLevel | string;
}
export interface CreatePlacementGroupResult {
    
    PlacementGroup?: PlacementGroup;
}
export interface CreatePublicIpv4PoolRequest {
    
    DryRun?: boolean;
    
    TagSpecifications?: TagSpecification[];
}
export interface CreatePublicIpv4PoolResult {
    
    PoolId?: string;
}
export interface CreateReplaceRootVolumeTaskRequest {
    
    InstanceId: string | undefined;
    
    SnapshotId?: string;
    
    ClientToken?: string;
    
    DryRun?: boolean;
    
    TagSpecifications?: TagSpecification[];
}
export declare enum ReplaceRootVolumeTaskState {
    failed = "failed",
    failed_detached = "failed-detached",
    failing = "failing",
    in_progress = "in-progress",
    pending = "pending",
    succeeded = "succeeded"
}

export interface ReplaceRootVolumeTask {
    
    ReplaceRootVolumeTaskId?: string;
    
    InstanceId?: string;
    
    TaskState?: ReplaceRootVolumeTaskState | string;
    
    StartTime?: string;
    
    CompleteTime?: string;
    
    Tags?: Tag[];
}
export interface CreateReplaceRootVolumeTaskResult {
    
    ReplaceRootVolumeTask?: ReplaceRootVolumeTask;
}

export interface PriceScheduleSpecification {
    
    CurrencyCode?: CurrencyCodeValues | string;
    
    Price?: number;
    
    Term?: number;
}

export interface CreateReservedInstancesListingRequest {
    
    ClientToken: string | undefined;
    
    InstanceCount: number | undefined;
    
    PriceSchedules: PriceScheduleSpecification[] | undefined;
    
    ReservedInstancesId: string | undefined;
}

export interface CreateReservedInstancesListingResult {
    
    ReservedInstancesListings?: ReservedInstancesListing[];
}
export interface CreateRestoreImageTaskRequest {
    
    Bucket: string | undefined;
    
    ObjectKey: string | undefined;
    
    Name?: string;
    
    TagSpecifications?: TagSpecification[];
    
    DryRun?: boolean;
}
export interface CreateRestoreImageTaskResult {
    
    ImageId?: string;
}
export interface CreateRouteRequest {
    
    DestinationCidrBlock?: string;
    
    DestinationIpv6CidrBlock?: string;
    
    DestinationPrefixListId?: string;
    
    DryRun?: boolean;
    
    VpcEndpointId?: string;
    
    EgressOnlyInternetGatewayId?: string;
    
    GatewayId?: string;
    
    InstanceId?: string;
    
    NatGatewayId?: string;
    
    TransitGatewayId?: string;
    
    LocalGatewayId?: string;
    
    CarrierGatewayId?: string;
    
    NetworkInterfaceId?: string;
    
    RouteTableId: string | undefined;
    
    VpcPeeringConnectionId?: string;
    
    CoreNetworkArn?: string;
}
export interface CreateRouteResult {
    
    Return?: boolean;
}
export interface CreateRouteTableRequest {
    
    DryRun?: boolean;
    
    VpcId: string | undefined;
    
    TagSpecifications?: TagSpecification[];
}

export interface RouteTableAssociation {
    
    Main?: boolean;
    
    RouteTableAssociationId?: string;
    
    RouteTableId?: string;
    
    SubnetId?: string;
    
    GatewayId?: string;
    
    AssociationState?: RouteTableAssociationState;
}

export interface PropagatingVgw {
    
    GatewayId?: string;
}
export declare type RouteOrigin = "CreateRoute" | "CreateRouteTable" | "EnableVgwRoutePropagation";
export declare type RouteState = "active" | "blackhole";

export interface Route {
    
    DestinationCidrBlock?: string;
    
    DestinationIpv6CidrBlock?: string;
    
    DestinationPrefixListId?: string;
    
    EgressOnlyInternetGatewayId?: string;
    
    GatewayId?: string;
    
    InstanceId?: string;
    
    InstanceOwnerId?: string;
    
    NatGatewayId?: string;
    
    TransitGatewayId?: string;
    
    LocalGatewayId?: string;
    
    CarrierGatewayId?: string;
    
    NetworkInterfaceId?: string;
    
    Origin?: RouteOrigin | string;
    
    State?: RouteState | string;
    
    VpcPeeringConnectionId?: string;
    
    CoreNetworkArn?: string;
}

export interface RouteTable {
    
    Associations?: RouteTableAssociation[];
    
    PropagatingVgws?: PropagatingVgw[];
    
    RouteTableId?: string;
    
    Routes?: Route[];
    
    Tags?: Tag[];
    
    VpcId?: string;
    
    OwnerId?: string;
}
export interface CreateRouteTableResult {
    
    RouteTable?: RouteTable;
}
export interface CreateSecurityGroupRequest {
    
    Description: string | undefined;
    
    GroupName: string | undefined;
    
    VpcId?: string;
    
    TagSpecifications?: TagSpecification[];
    
    DryRun?: boolean;
}
export interface CreateSecurityGroupResult {
    
    GroupId?: string;
    
    Tags?: Tag[];
}
export interface CreateSnapshotRequest {
    
    Description?: string;
    
    OutpostArn?: string;
    
    VolumeId: string | undefined;
    
    TagSpecifications?: TagSpecification[];
    
    DryRun?: boolean;
}
export declare type SnapshotState = "completed" | "error" | "pending" | "recoverable" | "recovering";
export declare enum StorageTier {
    archive = "archive",
    standard = "standard"
}

export interface Snapshot {
    
    DataEncryptionKeyId?: string;
    
    Description?: string;
    
    Encrypted?: boolean;
    
    KmsKeyId?: string;
    
    OwnerId?: string;
    
    Progress?: string;
    
    SnapshotId?: string;
    
    StartTime?: Date;
    
    State?: SnapshotState | string;
    
    StateMessage?: string;
    
    VolumeId?: string;
    
    VolumeSize?: number;
    
    OwnerAlias?: string;
    
    OutpostArn?: string;
    
    Tags?: Tag[];
    
    StorageTier?: StorageTier | string;
    
    RestoreExpiryTime?: Date;
}
export declare type CopyTagsFromSource = "volume";

export interface InstanceSpecification {
    
    InstanceId?: string;
    
    ExcludeBootVolume?: boolean;
}
export interface CreateSnapshotsRequest {
    
    Description?: string;
    
    InstanceSpecification: InstanceSpecification | undefined;
    
    OutpostArn?: string;
    
    TagSpecifications?: TagSpecification[];
    
    DryRun?: boolean;
    
    CopyTagsFromSource?: CopyTagsFromSource | string;
}

export interface SnapshotInfo {
    
    Description?: string;
    
    Tags?: Tag[];
    
    Encrypted?: boolean;
    
    VolumeId?: string;
    
    State?: SnapshotState | string;
    
    VolumeSize?: number;
    
    StartTime?: Date;
    
    Progress?: string;
    
    OwnerId?: string;
    
    SnapshotId?: string;
    
    OutpostArn?: string;
}
export interface CreateSnapshotsResult {
    
    Snapshots?: SnapshotInfo[];
}

export interface CreateSpotDatafeedSubscriptionRequest {
    
    Bucket: string | undefined;
    
    DryRun?: boolean;
    
    Prefix?: string;
}

export interface SpotInstanceStateFault {
    
    Code?: string;
    
    Message?: string;
}
export declare type DatafeedSubscriptionState = "Active" | "Inactive";

export interface SpotDatafeedSubscription {
    
    Bucket?: string;
    
    Fault?: SpotInstanceStateFault;
    
    OwnerId?: string;
    
    Prefix?: string;
    
    State?: DatafeedSubscriptionState | string;
}

export interface CreateSpotDatafeedSubscriptionResult {
    
    SpotDatafeedSubscription?: SpotDatafeedSubscription;
}

export interface S3ObjectTag {
    
    Key?: string;
    
    Value?: string;
}
export interface CreateStoreImageTaskRequest {
    
    ImageId: string | undefined;
    
    Bucket: string | undefined;
    
    S3ObjectTags?: S3ObjectTag[];
    
    DryRun?: boolean;
}
export interface CreateStoreImageTaskResult {
    
    ObjectKey?: string;
}
export interface CreateSubnetRequest {
    
    TagSpecifications?: TagSpecification[];
    
    AvailabilityZone?: string;
    
    AvailabilityZoneId?: string;
    
    CidrBlock?: string;
    
    Ipv6CidrBlock?: string;
    
    OutpostArn?: string;
    
    VpcId: string | undefined;
    
    DryRun?: boolean;
    
    Ipv6Native?: boolean;
}
export interface CreateSubnetResult {
    
    Subnet?: Subnet;
}
export declare enum SubnetCidrReservationType {
    explicit = "explicit",
    prefix = "prefix"
}
export interface CreateSubnetCidrReservationRequest {
    
    SubnetId: string | undefined;
    
    Cidr: string | undefined;
    
    ReservationType: SubnetCidrReservationType | string | undefined;
    
    Description?: string;
    
    DryRun?: boolean;
    
    TagSpecifications?: TagSpecification[];
}

export interface SubnetCidrReservation {
    
    SubnetCidrReservationId?: string;
    
    SubnetId?: string;
    
    Cidr?: string;
    
    ReservationType?: SubnetCidrReservationType | string;
    
    OwnerId?: string;
    
    Description?: string;
    
    Tags?: Tag[];
}
export interface CreateSubnetCidrReservationResult {
    
    SubnetCidrReservation?: SubnetCidrReservation;
}
export interface CreateTagsRequest {
    
    DryRun?: boolean;
    
    Resources: string[] | undefined;
    
    Tags: Tag[] | undefined;
}
export interface CreateTrafficMirrorFilterRequest {
    
    Description?: string;
    
    TagSpecifications?: TagSpecification[];
    
    DryRun?: boolean;
    
    ClientToken?: string;
}

export interface TrafficMirrorPortRange {
    
    FromPort?: number;
    
    ToPort?: number;
}
export declare type TrafficMirrorRuleAction = "accept" | "reject";
export declare type TrafficDirection = "egress" | "ingress";

export interface TrafficMirrorFilterRule {
    
    TrafficMirrorFilterRuleId?: string;
    
    TrafficMirrorFilterId?: string;
    
    TrafficDirection?: TrafficDirection | string;
    
    RuleNumber?: number;
    
    RuleAction?: TrafficMirrorRuleAction | string;
    
    Protocol?: number;
    
    DestinationPortRange?: TrafficMirrorPortRange;
    
    SourcePortRange?: TrafficMirrorPortRange;
    
    DestinationCidrBlock?: string;
    
    SourceCidrBlock?: string;
    
    Description?: string;
}
export declare type TrafficMirrorNetworkService = "amazon-dns";

export interface TrafficMirrorFilter {
    
    TrafficMirrorFilterId?: string;
    
    IngressFilterRules?: TrafficMirrorFilterRule[];
    
    EgressFilterRules?: TrafficMirrorFilterRule[];
    
    NetworkServices?: (TrafficMirrorNetworkService | string)[];
    
    Description?: string;
    
    Tags?: Tag[];
}
export interface CreateTrafficMirrorFilterResult {
    
    TrafficMirrorFilter?: TrafficMirrorFilter;
    
    ClientToken?: string;
}

export interface TrafficMirrorPortRangeRequest {
    
    FromPort?: number;
    
    ToPort?: number;
}
export interface CreateTrafficMirrorFilterRuleRequest {
    
    TrafficMirrorFilterId: string | undefined;
    
    TrafficDirection: TrafficDirection | string | undefined;
    
    RuleNumber: number | undefined;
    
    RuleAction: TrafficMirrorRuleAction | string | undefined;
    
    DestinationPortRange?: TrafficMirrorPortRangeRequest;
    
    SourcePortRange?: TrafficMirrorPortRangeRequest;
    
    Protocol?: number;
    
    DestinationCidrBlock: string | undefined;
    
    SourceCidrBlock: string | undefined;
    
    Description?: string;
    
    DryRun?: boolean;
    
    ClientToken?: string;
}
export interface CreateTrafficMirrorFilterRuleResult {
    
    TrafficMirrorFilterRule?: TrafficMirrorFilterRule;
    
    ClientToken?: string;
}
export interface CreateTrafficMirrorSessionRequest {
    
    NetworkInterfaceId: string | undefined;
    
    TrafficMirrorTargetId: string | undefined;
    
    TrafficMirrorFilterId: string | undefined;
    
    PacketLength?: number;
    
    SessionNumber: number | undefined;
    
    VirtualNetworkId?: number;
    
    Description?: string;
    
    TagSpecifications?: TagSpecification[];
    
    DryRun?: boolean;
    
    ClientToken?: string;
}

export interface TrafficMirrorSession {
    
    TrafficMirrorSessionId?: string;
    
    TrafficMirrorTargetId?: string;
    
    TrafficMirrorFilterId?: string;
    
    NetworkInterfaceId?: string;
    
    OwnerId?: string;
    
    PacketLength?: number;
    
    SessionNumber?: number;
    
    VirtualNetworkId?: number;
    
    Description?: string;
    
    Tags?: Tag[];
}
export interface CreateTrafficMirrorSessionResult {
    
    TrafficMirrorSession?: TrafficMirrorSession;
    
    ClientToken?: string;
}
export interface CreateTrafficMirrorTargetRequest {
    
    NetworkInterfaceId?: string;
    
    NetworkLoadBalancerArn?: string;
    
    Description?: string;
    
    TagSpecifications?: TagSpecification[];
    
    DryRun?: boolean;
    
    ClientToken?: string;
    
    GatewayLoadBalancerEndpointId?: string;
}
export declare type TrafficMirrorTargetType = "gateway-load-balancer-endpoint" | "network-interface" | "network-load-balancer";

export interface TrafficMirrorTarget {
    
    TrafficMirrorTargetId?: string;
    
    NetworkInterfaceId?: string;
    
    NetworkLoadBalancerArn?: string;
    
    Type?: TrafficMirrorTargetType | string;
    
    Description?: string;
    
    OwnerId?: string;
    
    Tags?: Tag[];
    
    GatewayLoadBalancerEndpointId?: string;
}
export interface CreateTrafficMirrorTargetResult {
    
    TrafficMirrorTarget?: TrafficMirrorTarget;
    
    ClientToken?: string;
}
export declare type AutoAcceptSharedAttachmentsValue = "disable" | "enable";
export declare type DefaultRouteTableAssociationValue = "disable" | "enable";
export declare type DefaultRouteTablePropagationValue = "disable" | "enable";
export declare type MulticastSupportValue = "disable" | "enable";
export declare type VpnEcmpSupportValue = "disable" | "enable";

export interface TransitGatewayRequestOptions {
    
    AmazonSideAsn?: number;
    
    AutoAcceptSharedAttachments?: AutoAcceptSharedAttachmentsValue | string;
    
    DefaultRouteTableAssociation?: DefaultRouteTableAssociationValue | string;
    
    DefaultRouteTablePropagation?: DefaultRouteTablePropagationValue | string;
    
    VpnEcmpSupport?: VpnEcmpSupportValue | string;
    
    DnsSupport?: DnsSupportValue | string;
    
    MulticastSupport?: MulticastSupportValue | string;
    
    TransitGatewayCidrBlocks?: string[];
}
export interface CreateTransitGatewayRequest {
    
    Description?: string;
    
    Options?: TransitGatewayRequestOptions;
    
    TagSpecifications?: TagSpecification[];
    
    DryRun?: boolean;
}

export declare const FleetLaunchTemplateSpecificationRequestFilterSensitiveLog: (obj: FleetLaunchTemplateSpecificationRequest) => any;

export declare const BaselineEbsBandwidthMbpsRequestFilterSensitiveLog: (obj: BaselineEbsBandwidthMbpsRequest) => any;

export declare const MemoryGiBPerVCpuRequestFilterSensitiveLog: (obj: MemoryGiBPerVCpuRequest) => any;

export declare const MemoryMiBRequestFilterSensitiveLog: (obj: MemoryMiBRequest) => any;

export declare const NetworkInterfaceCountRequestFilterSensitiveLog: (obj: NetworkInterfaceCountRequest) => any;

export declare const TotalLocalStorageGBRequestFilterSensitiveLog: (obj: TotalLocalStorageGBRequest) => any;

export declare const VCpuCountRangeRequestFilterSensitiveLog: (obj: VCpuCountRangeRequest) => any;

export declare const InstanceRequirementsRequestFilterSensitiveLog: (obj: InstanceRequirementsRequest) => any;

export declare const PlacementFilterSensitiveLog: (obj: Placement) => any;

export declare const FleetLaunchTemplateOverridesRequestFilterSensitiveLog: (obj: FleetLaunchTemplateOverridesRequest) => any;

export declare const FleetLaunchTemplateConfigRequestFilterSensitiveLog: (obj: FleetLaunchTemplateConfigRequest) => any;

export declare const CapacityReservationOptionsRequestFilterSensitiveLog: (obj: CapacityReservationOptionsRequest) => any;

export declare const OnDemandOptionsRequestFilterSensitiveLog: (obj: OnDemandOptionsRequest) => any;

export declare const FleetSpotCapacityRebalanceRequestFilterSensitiveLog: (obj: FleetSpotCapacityRebalanceRequest) => any;

export declare const FleetSpotMaintenanceStrategiesRequestFilterSensitiveLog: (obj: FleetSpotMaintenanceStrategiesRequest) => any;

export declare const SpotOptionsRequestFilterSensitiveLog: (obj: SpotOptionsRequest) => any;

export declare const TargetCapacitySpecificationRequestFilterSensitiveLog: (obj: TargetCapacitySpecificationRequest) => any;

export declare const CreateFleetRequestFilterSensitiveLog: (obj: CreateFleetRequest) => any;

export declare const FleetLaunchTemplateSpecificationFilterSensitiveLog: (obj: FleetLaunchTemplateSpecification) => any;

export declare const BaselineEbsBandwidthMbpsFilterSensitiveLog: (obj: BaselineEbsBandwidthMbps) => any;

export declare const MemoryGiBPerVCpuFilterSensitiveLog: (obj: MemoryGiBPerVCpu) => any;

export declare const MemoryMiBFilterSensitiveLog: (obj: MemoryMiB) => any;

export declare const NetworkInterfaceCountFilterSensitiveLog: (obj: NetworkInterfaceCount) => any;

export declare const TotalLocalStorageGBFilterSensitiveLog: (obj: TotalLocalStorageGB) => any;

export declare const VCpuCountRangeFilterSensitiveLog: (obj: VCpuCountRange) => any;

export declare const InstanceRequirementsFilterSensitiveLog: (obj: InstanceRequirements) => any;

export declare const PlacementResponseFilterSensitiveLog: (obj: PlacementResponse) => any;

export declare const FleetLaunchTemplateOverridesFilterSensitiveLog: (obj: FleetLaunchTemplateOverrides) => any;

export declare const LaunchTemplateAndOverridesResponseFilterSensitiveLog: (obj: LaunchTemplateAndOverridesResponse) => any;

export declare const CreateFleetErrorFilterSensitiveLog: (obj: CreateFleetError) => any;

export declare const CreateFleetInstanceFilterSensitiveLog: (obj: CreateFleetInstance) => any;

export declare const CreateFleetResultFilterSensitiveLog: (obj: CreateFleetResult) => any;

export declare const DestinationOptionsRequestFilterSensitiveLog: (obj: DestinationOptionsRequest) => any;

export declare const CreateFlowLogsRequestFilterSensitiveLog: (obj: CreateFlowLogsRequest) => any;

export declare const CreateFlowLogsResultFilterSensitiveLog: (obj: CreateFlowLogsResult) => any;

export declare const StorageLocationFilterSensitiveLog: (obj: StorageLocation) => any;

export declare const CreateFpgaImageRequestFilterSensitiveLog: (obj: CreateFpgaImageRequest) => any;

export declare const CreateFpgaImageResultFilterSensitiveLog: (obj: CreateFpgaImageResult) => any;

export declare const EbsBlockDeviceFilterSensitiveLog: (obj: EbsBlockDevice) => any;

export declare const BlockDeviceMappingFilterSensitiveLog: (obj: BlockDeviceMapping) => any;

export declare const CreateImageRequestFilterSensitiveLog: (obj: CreateImageRequest) => any;

export declare const CreateImageResultFilterSensitiveLog: (obj: CreateImageResult) => any;

export declare const InstanceEventWindowTimeRangeRequestFilterSensitiveLog: (obj: InstanceEventWindowTimeRangeRequest) => any;

export declare const CreateInstanceEventWindowRequestFilterSensitiveLog: (obj: CreateInstanceEventWindowRequest) => any;

export declare const CreateInstanceEventWindowResultFilterSensitiveLog: (obj: CreateInstanceEventWindowResult) => any;

export declare const ExportToS3TaskSpecificationFilterSensitiveLog: (obj: ExportToS3TaskSpecification) => any;

export declare const CreateInstanceExportTaskRequestFilterSensitiveLog: (obj: CreateInstanceExportTaskRequest) => any;

export declare const ExportToS3TaskFilterSensitiveLog: (obj: ExportToS3Task) => any;

export declare const InstanceExportDetailsFilterSensitiveLog: (obj: InstanceExportDetails) => any;

export declare const ExportTaskFilterSensitiveLog: (obj: ExportTask) => any;

export declare const CreateInstanceExportTaskResultFilterSensitiveLog: (obj: CreateInstanceExportTaskResult) => any;

export declare const CreateInternetGatewayRequestFilterSensitiveLog: (obj: CreateInternetGatewayRequest) => any;

export declare const InternetGatewayFilterSensitiveLog: (obj: InternetGateway) => any;

export declare const CreateInternetGatewayResultFilterSensitiveLog: (obj: CreateInternetGatewayResult) => any;

export declare const CreateIpamRequestFilterSensitiveLog: (obj: CreateIpamRequest) => any;

export declare const IpamOperatingRegionFilterSensitiveLog: (obj: IpamOperatingRegion) => any;

export declare const IpamFilterSensitiveLog: (obj: Ipam) => any;

export declare const CreateIpamResultFilterSensitiveLog: (obj: CreateIpamResult) => any;

export declare const RequestIpamResourceTagFilterSensitiveLog: (obj: RequestIpamResourceTag) => any;

export declare const CreateIpamPoolRequestFilterSensitiveLog: (obj: CreateIpamPoolRequest) => any;

export declare const IpamResourceTagFilterSensitiveLog: (obj: IpamResourceTag) => any;

export declare const IpamPoolFilterSensitiveLog: (obj: IpamPool) => any;

export declare const CreateIpamPoolResultFilterSensitiveLog: (obj: CreateIpamPoolResult) => any;

export declare const CreateIpamScopeRequestFilterSensitiveLog: (obj: CreateIpamScopeRequest) => any;

export declare const IpamScopeFilterSensitiveLog: (obj: IpamScope) => any;

export declare const CreateIpamScopeResultFilterSensitiveLog: (obj: CreateIpamScopeResult) => any;

export declare const CreateKeyPairRequestFilterSensitiveLog: (obj: CreateKeyPairRequest) => any;

export declare const KeyPairFilterSensitiveLog: (obj: KeyPair) => any;

export declare const LaunchTemplateEbsBlockDeviceRequestFilterSensitiveLog: (obj: LaunchTemplateEbsBlockDeviceRequest) => any;

export declare const LaunchTemplateBlockDeviceMappingRequestFilterSensitiveLog: (obj: LaunchTemplateBlockDeviceMappingRequest) => any;

export declare const CapacityReservationTargetFilterSensitiveLog: (obj: CapacityReservationTarget) => any;

export declare const LaunchTemplateCapacityReservationSpecificationRequestFilterSensitiveLog: (obj: LaunchTemplateCapacityReservationSpecificationRequest) => any;

export declare const LaunchTemplateCpuOptionsRequestFilterSensitiveLog: (obj: LaunchTemplateCpuOptionsRequest) => any;

export declare const CreditSpecificationRequestFilterSensitiveLog: (obj: CreditSpecificationRequest) => any;

export declare const ElasticGpuSpecificationFilterSensitiveLog: (obj: ElasticGpuSpecification) => any;

export declare const LaunchTemplateElasticInferenceAcceleratorFilterSensitiveLog: (obj: LaunchTemplateElasticInferenceAccelerator) => any;

export declare const LaunchTemplateEnclaveOptionsRequestFilterSensitiveLog: (obj: LaunchTemplateEnclaveOptionsRequest) => any;

export declare const LaunchTemplateHibernationOptionsRequestFilterSensitiveLog: (obj: LaunchTemplateHibernationOptionsRequest) => any;

export declare const LaunchTemplateIamInstanceProfileSpecificationRequestFilterSensitiveLog: (obj: LaunchTemplateIamInstanceProfileSpecificationRequest) => any;

export declare const LaunchTemplateSpotMarketOptionsRequestFilterSensitiveLog: (obj: LaunchTemplateSpotMarketOptionsRequest) => any;

export declare const LaunchTemplateInstanceMarketOptionsRequestFilterSensitiveLog: (obj: LaunchTemplateInstanceMarketOptionsRequest) => any;

export declare const LaunchTemplateLicenseConfigurationRequestFilterSensitiveLog: (obj: LaunchTemplateLicenseConfigurationRequest) => any;

export declare const LaunchTemplateInstanceMaintenanceOptionsRequestFilterSensitiveLog: (obj: LaunchTemplateInstanceMaintenanceOptionsRequest) => any;

export declare const LaunchTemplateInstanceMetadataOptionsRequestFilterSensitiveLog: (obj: LaunchTemplateInstanceMetadataOptionsRequest) => any;

export declare const LaunchTemplatesMonitoringRequestFilterSensitiveLog: (obj: LaunchTemplatesMonitoringRequest) => any;

export declare const Ipv4PrefixSpecificationRequestFilterSensitiveLog: (obj: Ipv4PrefixSpecificationRequest) => any;

export declare const InstanceIpv6AddressRequestFilterSensitiveLog: (obj: InstanceIpv6AddressRequest) => any;

export declare const Ipv6PrefixSpecificationRequestFilterSensitiveLog: (obj: Ipv6PrefixSpecificationRequest) => any;

export declare const PrivateIpAddressSpecificationFilterSensitiveLog: (obj: PrivateIpAddressSpecification) => any;

export declare const LaunchTemplateInstanceNetworkInterfaceSpecificationRequestFilterSensitiveLog: (obj: LaunchTemplateInstanceNetworkInterfaceSpecificationRequest) => any;

export declare const LaunchTemplatePlacementRequestFilterSensitiveLog: (obj: LaunchTemplatePlacementRequest) => any;

export declare const LaunchTemplatePrivateDnsNameOptionsRequestFilterSensitiveLog: (obj: LaunchTemplatePrivateDnsNameOptionsRequest) => any;

export declare const LaunchTemplateTagSpecificationRequestFilterSensitiveLog: (obj: LaunchTemplateTagSpecificationRequest) => any;

export declare const RequestLaunchTemplateDataFilterSensitiveLog: (obj: RequestLaunchTemplateData) => any;

export declare const CreateLaunchTemplateRequestFilterSensitiveLog: (obj: CreateLaunchTemplateRequest) => any;

export declare const LaunchTemplateFilterSensitiveLog: (obj: LaunchTemplate) => any;

export declare const ValidationErrorFilterSensitiveLog: (obj: ValidationError) => any;

export declare const ValidationWarningFilterSensitiveLog: (obj: ValidationWarning) => any;

export declare const CreateLaunchTemplateResultFilterSensitiveLog: (obj: CreateLaunchTemplateResult) => any;

export declare const CreateLaunchTemplateVersionRequestFilterSensitiveLog: (obj: CreateLaunchTemplateVersionRequest) => any;

export declare const LaunchTemplateEbsBlockDeviceFilterSensitiveLog: (obj: LaunchTemplateEbsBlockDevice) => any;

export declare const LaunchTemplateBlockDeviceMappingFilterSensitiveLog: (obj: LaunchTemplateBlockDeviceMapping) => any;

export declare const CapacityReservationTargetResponseFilterSensitiveLog: (obj: CapacityReservationTargetResponse) => any;

export declare const LaunchTemplateCapacityReservationSpecificationResponseFilterSensitiveLog: (obj: LaunchTemplateCapacityReservationSpecificationResponse) => any;

export declare const LaunchTemplateCpuOptionsFilterSensitiveLog: (obj: LaunchTemplateCpuOptions) => any;

export declare const CreditSpecificationFilterSensitiveLog: (obj: CreditSpecification) => any;

export declare const ElasticGpuSpecificationResponseFilterSensitiveLog: (obj: ElasticGpuSpecificationResponse) => any;

export declare const LaunchTemplateElasticInferenceAcceleratorResponseFilterSensitiveLog: (obj: LaunchTemplateElasticInferenceAcceleratorResponse) => any;

export declare const LaunchTemplateEnclaveOptionsFilterSensitiveLog: (obj: LaunchTemplateEnclaveOptions) => any;

export declare const LaunchTemplateHibernationOptionsFilterSensitiveLog: (obj: LaunchTemplateHibernationOptions) => any;

export declare const LaunchTemplateIamInstanceProfileSpecificationFilterSensitiveLog: (obj: LaunchTemplateIamInstanceProfileSpecification) => any;

export declare const LaunchTemplateSpotMarketOptionsFilterSensitiveLog: (obj: LaunchTemplateSpotMarketOptions) => any;

export declare const LaunchTemplateInstanceMarketOptionsFilterSensitiveLog: (obj: LaunchTemplateInstanceMarketOptions) => any;

export declare const LaunchTemplateLicenseConfigurationFilterSensitiveLog: (obj: LaunchTemplateLicenseConfiguration) => any;

export declare const LaunchTemplateInstanceMaintenanceOptionsFilterSensitiveLog: (obj: LaunchTemplateInstanceMaintenanceOptions) => any;

export declare const LaunchTemplateInstanceMetadataOptionsFilterSensitiveLog: (obj: LaunchTemplateInstanceMetadataOptions) => any;

export declare const LaunchTemplatesMonitoringFilterSensitiveLog: (obj: LaunchTemplatesMonitoring) => any;

export declare const Ipv4PrefixSpecificationResponseFilterSensitiveLog: (obj: Ipv4PrefixSpecificationResponse) => any;

export declare const InstanceIpv6AddressFilterSensitiveLog: (obj: InstanceIpv6Address) => any;

export declare const Ipv6PrefixSpecificationResponseFilterSensitiveLog: (obj: Ipv6PrefixSpecificationResponse) => any;

export declare const LaunchTemplateInstanceNetworkInterfaceSpecificationFilterSensitiveLog: (obj: LaunchTemplateInstanceNetworkInterfaceSpecification) => any;

export declare const LaunchTemplatePlacementFilterSensitiveLog: (obj: LaunchTemplatePlacement) => any;

export declare const LaunchTemplatePrivateDnsNameOptionsFilterSensitiveLog: (obj: LaunchTemplatePrivateDnsNameOptions) => any;

export declare const LaunchTemplateTagSpecificationFilterSensitiveLog: (obj: LaunchTemplateTagSpecification) => any;

export declare const ResponseLaunchTemplateDataFilterSensitiveLog: (obj: ResponseLaunchTemplateData) => any;

export declare const LaunchTemplateVersionFilterSensitiveLog: (obj: LaunchTemplateVersion) => any;

export declare const CreateLaunchTemplateVersionResultFilterSensitiveLog: (obj: CreateLaunchTemplateVersionResult) => any;

export declare const CreateLocalGatewayRouteRequestFilterSensitiveLog: (obj: CreateLocalGatewayRouteRequest) => any;

export declare const LocalGatewayRouteFilterSensitiveLog: (obj: LocalGatewayRoute) => any;

export declare const CreateLocalGatewayRouteResultFilterSensitiveLog: (obj: CreateLocalGatewayRouteResult) => any;

export declare const CreateLocalGatewayRouteTableVpcAssociationRequestFilterSensitiveLog: (obj: CreateLocalGatewayRouteTableVpcAssociationRequest) => any;

export declare const LocalGatewayRouteTableVpcAssociationFilterSensitiveLog: (obj: LocalGatewayRouteTableVpcAssociation) => any;

export declare const CreateLocalGatewayRouteTableVpcAssociationResultFilterSensitiveLog: (obj: CreateLocalGatewayRouteTableVpcAssociationResult) => any;

export declare const CreateManagedPrefixListRequestFilterSensitiveLog: (obj: CreateManagedPrefixListRequest) => any;

export declare const ManagedPrefixListFilterSensitiveLog: (obj: ManagedPrefixList) => any;

export declare const CreateManagedPrefixListResultFilterSensitiveLog: (obj: CreateManagedPrefixListResult) => any;

export declare const CreateNatGatewayRequestFilterSensitiveLog: (obj: CreateNatGatewayRequest) => any;

export declare const NatGatewayAddressFilterSensitiveLog: (obj: NatGatewayAddress) => any;

export declare const ProvisionedBandwidthFilterSensitiveLog: (obj: ProvisionedBandwidth) => any;

export declare const NatGatewayFilterSensitiveLog: (obj: NatGateway) => any;

export declare const CreateNatGatewayResultFilterSensitiveLog: (obj: CreateNatGatewayResult) => any;

export declare const CreateNetworkAclRequestFilterSensitiveLog: (obj: CreateNetworkAclRequest) => any;

export declare const NetworkAclAssociationFilterSensitiveLog: (obj: NetworkAclAssociation) => any;

export declare const IcmpTypeCodeFilterSensitiveLog: (obj: IcmpTypeCode) => any;

export declare const NetworkAclEntryFilterSensitiveLog: (obj: NetworkAclEntry) => any;

export declare const NetworkAclFilterSensitiveLog: (obj: NetworkAcl) => any;

export declare const CreateNetworkAclResultFilterSensitiveLog: (obj: CreateNetworkAclResult) => any;

export declare const CreateNetworkAclEntryRequestFilterSensitiveLog: (obj: CreateNetworkAclEntryRequest) => any;

export declare const CreateNetworkInsightsAccessScopeRequestFilterSensitiveLog: (obj: CreateNetworkInsightsAccessScopeRequest) => any;

export declare const NetworkInsightsAccessScopeFilterSensitiveLog: (obj: NetworkInsightsAccessScope) => any;

export declare const NetworkInsightsAccessScopeContentFilterSensitiveLog: (obj: NetworkInsightsAccessScopeContent) => any;

export declare const CreateNetworkInsightsAccessScopeResultFilterSensitiveLog: (obj: CreateNetworkInsightsAccessScopeResult) => any;

export declare const CreateNetworkInsightsPathRequestFilterSensitiveLog: (obj: CreateNetworkInsightsPathRequest) => any;

export declare const NetworkInsightsPathFilterSensitiveLog: (obj: NetworkInsightsPath) => any;

export declare const CreateNetworkInsightsPathResultFilterSensitiveLog: (obj: CreateNetworkInsightsPathResult) => any;

export declare const CreateNetworkInterfaceRequestFilterSensitiveLog: (obj: CreateNetworkInterfaceRequest) => any;

export declare const NetworkInterfaceAssociationFilterSensitiveLog: (obj: NetworkInterfaceAssociation) => any;

export declare const NetworkInterfaceAttachmentFilterSensitiveLog: (obj: NetworkInterfaceAttachment) => any;

export declare const GroupIdentifierFilterSensitiveLog: (obj: GroupIdentifier) => any;

export declare const NetworkInterfaceIpv6AddressFilterSensitiveLog: (obj: NetworkInterfaceIpv6Address) => any;

export declare const Ipv6PrefixSpecificationFilterSensitiveLog: (obj: Ipv6PrefixSpecification) => any;

export declare const NetworkInterfacePrivateIpAddressFilterSensitiveLog: (obj: NetworkInterfacePrivateIpAddress) => any;

export declare const NetworkInterfaceFilterSensitiveLog: (obj: NetworkInterface) => any;

export declare const CreateNetworkInterfaceResultFilterSensitiveLog: (obj: CreateNetworkInterfaceResult) => any;

export declare const CreateNetworkInterfacePermissionRequestFilterSensitiveLog: (obj: CreateNetworkInterfacePermissionRequest) => any;

export declare const NetworkInterfacePermissionStateFilterSensitiveLog: (obj: NetworkInterfacePermissionState) => any;

export declare const NetworkInterfacePermissionFilterSensitiveLog: (obj: NetworkInterfacePermission) => any;

export declare const CreateNetworkInterfacePermissionResultFilterSensitiveLog: (obj: CreateNetworkInterfacePermissionResult) => any;

export declare const CreatePlacementGroupRequestFilterSensitiveLog: (obj: CreatePlacementGroupRequest) => any;

export declare const PlacementGroupFilterSensitiveLog: (obj: PlacementGroup) => any;

export declare const CreatePlacementGroupResultFilterSensitiveLog: (obj: CreatePlacementGroupResult) => any;

export declare const CreatePublicIpv4PoolRequestFilterSensitiveLog: (obj: CreatePublicIpv4PoolRequest) => any;

export declare const CreatePublicIpv4PoolResultFilterSensitiveLog: (obj: CreatePublicIpv4PoolResult) => any;

export declare const CreateReplaceRootVolumeTaskRequestFilterSensitiveLog: (obj: CreateReplaceRootVolumeTaskRequest) => any;

export declare const ReplaceRootVolumeTaskFilterSensitiveLog: (obj: ReplaceRootVolumeTask) => any;

export declare const CreateReplaceRootVolumeTaskResultFilterSensitiveLog: (obj: CreateReplaceRootVolumeTaskResult) => any;

export declare const PriceScheduleSpecificationFilterSensitiveLog: (obj: PriceScheduleSpecification) => any;

export declare const CreateReservedInstancesListingRequestFilterSensitiveLog: (obj: CreateReservedInstancesListingRequest) => any;

export declare const CreateReservedInstancesListingResultFilterSensitiveLog: (obj: CreateReservedInstancesListingResult) => any;

export declare const CreateRestoreImageTaskRequestFilterSensitiveLog: (obj: CreateRestoreImageTaskRequest) => any;

export declare const CreateRestoreImageTaskResultFilterSensitiveLog: (obj: CreateRestoreImageTaskResult) => any;

export declare const CreateRouteRequestFilterSensitiveLog: (obj: CreateRouteRequest) => any;

export declare const CreateRouteResultFilterSensitiveLog: (obj: CreateRouteResult) => any;

export declare const CreateRouteTableRequestFilterSensitiveLog: (obj: CreateRouteTableRequest) => any;

export declare const RouteTableAssociationFilterSensitiveLog: (obj: RouteTableAssociation) => any;

export declare const PropagatingVgwFilterSensitiveLog: (obj: PropagatingVgw) => any;

export declare const RouteFilterSensitiveLog: (obj: Route) => any;

export declare const RouteTableFilterSensitiveLog: (obj: RouteTable) => any;

export declare const CreateRouteTableResultFilterSensitiveLog: (obj: CreateRouteTableResult) => any;

export declare const CreateSecurityGroupRequestFilterSensitiveLog: (obj: CreateSecurityGroupRequest) => any;

export declare const CreateSecurityGroupResultFilterSensitiveLog: (obj: CreateSecurityGroupResult) => any;

export declare const CreateSnapshotRequestFilterSensitiveLog: (obj: CreateSnapshotRequest) => any;

export declare const SnapshotFilterSensitiveLog: (obj: Snapshot) => any;

export declare const InstanceSpecificationFilterSensitiveLog: (obj: InstanceSpecification) => any;

export declare const CreateSnapshotsRequestFilterSensitiveLog: (obj: CreateSnapshotsRequest) => any;

export declare const SnapshotInfoFilterSensitiveLog: (obj: SnapshotInfo) => any;

export declare const CreateSnapshotsResultFilterSensitiveLog: (obj: CreateSnapshotsResult) => any;

export declare const CreateSpotDatafeedSubscriptionRequestFilterSensitiveLog: (obj: CreateSpotDatafeedSubscriptionRequest) => any;

export declare const SpotInstanceStateFaultFilterSensitiveLog: (obj: SpotInstanceStateFault) => any;

export declare const SpotDatafeedSubscriptionFilterSensitiveLog: (obj: SpotDatafeedSubscription) => any;

export declare const CreateSpotDatafeedSubscriptionResultFilterSensitiveLog: (obj: CreateSpotDatafeedSubscriptionResult) => any;

export declare const S3ObjectTagFilterSensitiveLog: (obj: S3ObjectTag) => any;

export declare const CreateStoreImageTaskRequestFilterSensitiveLog: (obj: CreateStoreImageTaskRequest) => any;

export declare const CreateStoreImageTaskResultFilterSensitiveLog: (obj: CreateStoreImageTaskResult) => any;

export declare const CreateSubnetRequestFilterSensitiveLog: (obj: CreateSubnetRequest) => any;

export declare const CreateSubnetResultFilterSensitiveLog: (obj: CreateSubnetResult) => any;

export declare const CreateSubnetCidrReservationRequestFilterSensitiveLog: (obj: CreateSubnetCidrReservationRequest) => any;

export declare const SubnetCidrReservationFilterSensitiveLog: (obj: SubnetCidrReservation) => any;

export declare const CreateSubnetCidrReservationResultFilterSensitiveLog: (obj: CreateSubnetCidrReservationResult) => any;

export declare const CreateTagsRequestFilterSensitiveLog: (obj: CreateTagsRequest) => any;

export declare const CreateTrafficMirrorFilterRequestFilterSensitiveLog: (obj: CreateTrafficMirrorFilterRequest) => any;

export declare const TrafficMirrorPortRangeFilterSensitiveLog: (obj: TrafficMirrorPortRange) => any;

export declare const TrafficMirrorFilterRuleFilterSensitiveLog: (obj: TrafficMirrorFilterRule) => any;

export declare const TrafficMirrorFilterFilterSensitiveLog: (obj: TrafficMirrorFilter) => any;

export declare const CreateTrafficMirrorFilterResultFilterSensitiveLog: (obj: CreateTrafficMirrorFilterResult) => any;

export declare const TrafficMirrorPortRangeRequestFilterSensitiveLog: (obj: TrafficMirrorPortRangeRequest) => any;

export declare const CreateTrafficMirrorFilterRuleRequestFilterSensitiveLog: (obj: CreateTrafficMirrorFilterRuleRequest) => any;

export declare const CreateTrafficMirrorFilterRuleResultFilterSensitiveLog: (obj: CreateTrafficMirrorFilterRuleResult) => any;

export declare const CreateTrafficMirrorSessionRequestFilterSensitiveLog: (obj: CreateTrafficMirrorSessionRequest) => any;

export declare const TrafficMirrorSessionFilterSensitiveLog: (obj: TrafficMirrorSession) => any;

export declare const CreateTrafficMirrorSessionResultFilterSensitiveLog: (obj: CreateTrafficMirrorSessionResult) => any;

export declare const CreateTrafficMirrorTargetRequestFilterSensitiveLog: (obj: CreateTrafficMirrorTargetRequest) => any;

export declare const TrafficMirrorTargetFilterSensitiveLog: (obj: TrafficMirrorTarget) => any;

export declare const CreateTrafficMirrorTargetResultFilterSensitiveLog: (obj: CreateTrafficMirrorTargetResult) => any;

export declare const TransitGatewayRequestOptionsFilterSensitiveLog: (obj: TransitGatewayRequestOptions) => any;

export declare const CreateTransitGatewayRequestFilterSensitiveLog: (obj: CreateTransitGatewayRequest) => any;
