import { _InstanceType, ActiveInstance, ActivityStatus, AllocationState, AllocationStrategy, AllowsMultipleInstanceTypes, AlternatePathHint, AttachmentStatus, AttributeValue, AutoPlacement, BatchState, CurrencyCodeValues, FleetLaunchTemplateSpecification, FleetType, HostRecovery, IamInstanceProfile, IamInstanceProfileAssociation, IamInstanceProfileSpecification, InstanceEventWindow, IpPermission, Placement, ReservedInstancesListing, ResourceType, SecurityGroupRule, Tag, TagSpecification, TargetCapacityUnitType, Tenancy, UserIdGroupPair } from "./models_0";
import { BlockDeviceMapping, CapacityReservationPreference, CapacityReservationTargetResponse, GroupIdentifier, InstanceInterruptionBehavior, InstanceIpv6Address, InstanceRequirements, InternetGateway, Ipv4PrefixSpecificationRequest, Ipv6PrefixSpecificationRequest, KeyType, LaunchTemplate, LaunchTemplateVersion, LocalGatewayRouteTableVpcAssociation, ManagedPrefixList, NatGateway, NetworkAcl, NetworkInsightsPath, NetworkInterface, NetworkInterfaceAttachment, NetworkInterfacePermission, NetworkInterfaceStatus, PlacementGroup, PlatformValues, PortRange, PrivateIpAddressSpecification, ReplaceRootVolumeTask, RouteTable, Snapshot, SpotDatafeedSubscription, SpotInstanceStateFault, SpotInstanceType } from "./models_1";
import { EventInformation, Filter, IdFormat, InstanceTagNotificationAttribute, PermissionGroup, ProductCode } from "./models_2";

export interface InstanceCapacity {
    
    AvailableCapacity?: number;
    
    InstanceType?: string;
    
    TotalCapacity?: number;
}
export declare namespace InstanceCapacity {
    
    const filterSensitiveLog: (obj: InstanceCapacity) => any;
}

export interface AvailableCapacity {
    
    AvailableInstanceCapacity?: InstanceCapacity[];
    
    AvailableVCpus?: number;
}
export declare namespace AvailableCapacity {
    
    const filterSensitiveLog: (obj: AvailableCapacity) => any;
}

export interface HostProperties {
    
    Cores?: number;
    
    InstanceType?: string;
    
    InstanceFamily?: string;
    
    Sockets?: number;
    
    TotalVCpus?: number;
}
export declare namespace HostProperties {
    
    const filterSensitiveLog: (obj: HostProperties) => any;
}

export interface HostInstance {
    
    InstanceId?: string;
    
    InstanceType?: string;
    
    OwnerId?: string;
}
export declare namespace HostInstance {
    
    const filterSensitiveLog: (obj: HostInstance) => any;
}

export interface Host {
    
    AutoPlacement?: AutoPlacement | string;
    
    AvailabilityZone?: string;
    
    AvailableCapacity?: AvailableCapacity;
    
    ClientToken?: string;
    
    HostId?: string;
    
    HostProperties?: HostProperties;
    
    HostReservationId?: string;
    
    Instances?: HostInstance[];
    
    State?: AllocationState | string;
    
    AllocationTime?: Date;
    
    ReleaseTime?: Date;
    
    Tags?: Tag[];
    
    HostRecovery?: HostRecovery | string;
    
    AllowsMultipleInstanceTypes?: AllowsMultipleInstanceTypes | string;
    
    OwnerId?: string;
    
    AvailabilityZoneId?: string;
    
    MemberOfServiceLinkedResourceGroup?: boolean;
}
export declare namespace Host {
    
    const filterSensitiveLog: (obj: Host) => any;
}
export interface DescribeHostsResult {
    
    Hosts?: Host[];
    
    NextToken?: string;
}
export declare namespace DescribeHostsResult {
    
    const filterSensitiveLog: (obj: DescribeHostsResult) => any;
}
export interface DescribeIamInstanceProfileAssociationsRequest {
    
    AssociationIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeIamInstanceProfileAssociationsRequest {
    
    const filterSensitiveLog: (obj: DescribeIamInstanceProfileAssociationsRequest) => any;
}
export interface DescribeIamInstanceProfileAssociationsResult {
    
    IamInstanceProfileAssociations?: IamInstanceProfileAssociation[];
    
    NextToken?: string;
}
export declare namespace DescribeIamInstanceProfileAssociationsResult {
    
    const filterSensitiveLog: (obj: DescribeIamInstanceProfileAssociationsResult) => any;
}
export interface DescribeIdentityIdFormatRequest {
    
    PrincipalArn: string | undefined;
    
    Resource?: string;
}
export declare namespace DescribeIdentityIdFormatRequest {
    
    const filterSensitiveLog: (obj: DescribeIdentityIdFormatRequest) => any;
}
export interface DescribeIdentityIdFormatResult {
    
    Statuses?: IdFormat[];
}
export declare namespace DescribeIdentityIdFormatResult {
    
    const filterSensitiveLog: (obj: DescribeIdentityIdFormatResult) => any;
}
export interface DescribeIdFormatRequest {
    
    Resource?: string;
}
export declare namespace DescribeIdFormatRequest {
    
    const filterSensitiveLog: (obj: DescribeIdFormatRequest) => any;
}
export interface DescribeIdFormatResult {
    
    Statuses?: IdFormat[];
}
export declare namespace DescribeIdFormatResult {
    
    const filterSensitiveLog: (obj: DescribeIdFormatResult) => any;
}
export declare type ImageAttributeName = "blockDeviceMapping" | "bootMode" | "description" | "kernel" | "launchPermission" | "productCodes" | "ramdisk" | "sriovNetSupport";

export interface DescribeImageAttributeRequest {
    
    Attribute: ImageAttributeName | string | undefined;
    
    ImageId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace DescribeImageAttributeRequest {
    
    const filterSensitiveLog: (obj: DescribeImageAttributeRequest) => any;
}

export interface LaunchPermission {
    
    Group?: PermissionGroup | string;
    
    UserId?: string;
    
    OrganizationArn?: string;
    
    OrganizationalUnitArn?: string;
}
export declare namespace LaunchPermission {
    
    const filterSensitiveLog: (obj: LaunchPermission) => any;
}

export interface ImageAttribute {
    
    BlockDeviceMappings?: BlockDeviceMapping[];
    
    ImageId?: string;
    
    LaunchPermissions?: LaunchPermission[];
    
    ProductCodes?: ProductCode[];
    
    Description?: AttributeValue;
    
    KernelId?: AttributeValue;
    
    RamdiskId?: AttributeValue;
    
    SriovNetSupport?: AttributeValue;
    
    BootMode?: AttributeValue;
}
export declare namespace ImageAttribute {
    
    const filterSensitiveLog: (obj: ImageAttribute) => any;
}
export interface DescribeImagesRequest {
    
    ExecutableUsers?: string[];
    
    Filters?: Filter[];
    
    ImageIds?: string[];
    
    Owners?: string[];
    
    IncludeDeprecated?: boolean;
    
    DryRun?: boolean;
}
export declare namespace DescribeImagesRequest {
    
    const filterSensitiveLog: (obj: DescribeImagesRequest) => any;
}
export declare type ArchitectureValues = "arm64" | "i386" | "x86_64" | "x86_64_mac";
export declare type BootModeValues = "legacy-bios" | "uefi";
export declare type HypervisorType = "ovm" | "xen";
export declare type ImageTypeValues = "kernel" | "machine" | "ramdisk";
export declare type DeviceType = "ebs" | "instance-store";
export declare type ImageState = "available" | "deregistered" | "error" | "failed" | "invalid" | "pending" | "transient";

export interface StateReason {
    
    Code?: string;
    
    Message?: string;
}
export declare namespace StateReason {
    
    const filterSensitiveLog: (obj: StateReason) => any;
}
export declare type VirtualizationType = "hvm" | "paravirtual";

export interface Image {
    
    Architecture?: ArchitectureValues | string;
    
    CreationDate?: string;
    
    ImageId?: string;
    
    ImageLocation?: string;
    
    ImageType?: ImageTypeValues | string;
    
    Public?: boolean;
    
    KernelId?: string;
    
    OwnerId?: string;
    
    Platform?: PlatformValues | string;
    
    PlatformDetails?: string;
    
    UsageOperation?: string;
    
    ProductCodes?: ProductCode[];
    
    RamdiskId?: string;
    
    State?: ImageState | string;
    
    BlockDeviceMappings?: BlockDeviceMapping[];
    
    Description?: string;
    
    EnaSupport?: boolean;
    
    Hypervisor?: HypervisorType | string;
    
    ImageOwnerAlias?: string;
    
    Name?: string;
    
    RootDeviceName?: string;
    
    RootDeviceType?: DeviceType | string;
    
    SriovNetSupport?: string;
    
    StateReason?: StateReason;
    
    Tags?: Tag[];
    
    VirtualizationType?: VirtualizationType | string;
    
    BootMode?: BootModeValues | string;
    
    DeprecationTime?: string;
}
export declare namespace Image {
    
    const filterSensitiveLog: (obj: Image) => any;
}
export interface DescribeImagesResult {
    
    Images?: Image[];
}
export declare namespace DescribeImagesResult {
    
    const filterSensitiveLog: (obj: DescribeImagesResult) => any;
}
export interface DescribeImportImageTasksRequest {
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    ImportTaskIds?: string[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeImportImageTasksRequest {
    
    const filterSensitiveLog: (obj: DescribeImportImageTasksRequest) => any;
}

export interface ImportImageLicenseConfigurationResponse {
    
    LicenseConfigurationArn?: string;
}
export declare namespace ImportImageLicenseConfigurationResponse {
    
    const filterSensitiveLog: (obj: ImportImageLicenseConfigurationResponse) => any;
}

export interface UserBucketDetails {
    
    S3Bucket?: string;
    
    S3Key?: string;
}
export declare namespace UserBucketDetails {
    
    const filterSensitiveLog: (obj: UserBucketDetails) => any;
}

export interface SnapshotDetail {
    
    Description?: string;
    
    DeviceName?: string;
    
    DiskImageSize?: number;
    
    Format?: string;
    
    Progress?: string;
    
    SnapshotId?: string;
    
    Status?: string;
    
    StatusMessage?: string;
    
    Url?: string;
    
    UserBucket?: UserBucketDetails;
}
export declare namespace SnapshotDetail {
    
    const filterSensitiveLog: (obj: SnapshotDetail) => any;
}

export interface ImportImageTask {
    
    Architecture?: string;
    
    Description?: string;
    
    Encrypted?: boolean;
    
    Hypervisor?: string;
    
    ImageId?: string;
    
    ImportTaskId?: string;
    
    KmsKeyId?: string;
    
    LicenseType?: string;
    
    Platform?: string;
    
    Progress?: string;
    
    SnapshotDetails?: SnapshotDetail[];
    
    Status?: string;
    
    StatusMessage?: string;
    
    Tags?: Tag[];
    
    LicenseSpecifications?: ImportImageLicenseConfigurationResponse[];
    
    UsageOperation?: string;
    
    BootMode?: BootModeValues | string;
}
export declare namespace ImportImageTask {
    
    const filterSensitiveLog: (obj: ImportImageTask) => any;
}
export interface DescribeImportImageTasksResult {
    
    ImportImageTasks?: ImportImageTask[];
    
    NextToken?: string;
}
export declare namespace DescribeImportImageTasksResult {
    
    const filterSensitiveLog: (obj: DescribeImportImageTasksResult) => any;
}
export interface DescribeImportSnapshotTasksRequest {
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    ImportTaskIds?: string[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeImportSnapshotTasksRequest {
    
    const filterSensitiveLog: (obj: DescribeImportSnapshotTasksRequest) => any;
}

export interface SnapshotTaskDetail {
    
    Description?: string;
    
    DiskImageSize?: number;
    
    Encrypted?: boolean;
    
    Format?: string;
    
    KmsKeyId?: string;
    
    Progress?: string;
    
    SnapshotId?: string;
    
    Status?: string;
    
    StatusMessage?: string;
    
    Url?: string;
    
    UserBucket?: UserBucketDetails;
}
export declare namespace SnapshotTaskDetail {
    
    const filterSensitiveLog: (obj: SnapshotTaskDetail) => any;
}

export interface ImportSnapshotTask {
    
    Description?: string;
    
    ImportTaskId?: string;
    
    SnapshotTaskDetail?: SnapshotTaskDetail;
    
    Tags?: Tag[];
}
export declare namespace ImportSnapshotTask {
    
    const filterSensitiveLog: (obj: ImportSnapshotTask) => any;
}
export interface DescribeImportSnapshotTasksResult {
    
    ImportSnapshotTasks?: ImportSnapshotTask[];
    
    NextToken?: string;
}
export declare namespace DescribeImportSnapshotTasksResult {
    
    const filterSensitiveLog: (obj: DescribeImportSnapshotTasksResult) => any;
}
export declare type InstanceAttributeName = "blockDeviceMapping" | "disableApiTermination" | "ebsOptimized" | "enaSupport" | "enclaveOptions" | "groupSet" | "instanceInitiatedShutdownBehavior" | "instanceType" | "kernel" | "productCodes" | "ramdisk" | "rootDeviceName" | "sourceDestCheck" | "sriovNetSupport" | "userData";
export interface DescribeInstanceAttributeRequest {
    
    Attribute: InstanceAttributeName | string | undefined;
    
    DryRun?: boolean;
    
    InstanceId: string | undefined;
}
export declare namespace DescribeInstanceAttributeRequest {
    
    const filterSensitiveLog: (obj: DescribeInstanceAttributeRequest) => any;
}

export interface EbsInstanceBlockDevice {
    
    AttachTime?: Date;
    
    DeleteOnTermination?: boolean;
    
    Status?: AttachmentStatus | string;
    
    VolumeId?: string;
}
export declare namespace EbsInstanceBlockDevice {
    
    const filterSensitiveLog: (obj: EbsInstanceBlockDevice) => any;
}

export interface InstanceBlockDeviceMapping {
    
    DeviceName?: string;
    
    Ebs?: EbsInstanceBlockDevice;
}
export declare namespace InstanceBlockDeviceMapping {
    
    const filterSensitiveLog: (obj: InstanceBlockDeviceMapping) => any;
}

export interface AttributeBooleanValue {
    
    Value?: boolean;
}
export declare namespace AttributeBooleanValue {
    
    const filterSensitiveLog: (obj: AttributeBooleanValue) => any;
}

export interface EnclaveOptions {
    
    Enabled?: boolean;
}
export declare namespace EnclaveOptions {
    
    const filterSensitiveLog: (obj: EnclaveOptions) => any;
}

export interface InstanceAttribute {
    
    Groups?: GroupIdentifier[];
    
    BlockDeviceMappings?: InstanceBlockDeviceMapping[];
    
    DisableApiTermination?: AttributeBooleanValue;
    
    EnaSupport?: AttributeBooleanValue;
    
    EnclaveOptions?: EnclaveOptions;
    
    EbsOptimized?: AttributeBooleanValue;
    
    InstanceId?: string;
    
    InstanceInitiatedShutdownBehavior?: AttributeValue;
    
    InstanceType?: AttributeValue;
    
    KernelId?: AttributeValue;
    
    ProductCodes?: ProductCode[];
    
    RamdiskId?: AttributeValue;
    
    RootDeviceName?: AttributeValue;
    
    SourceDestCheck?: AttributeBooleanValue;
    
    SriovNetSupport?: AttributeValue;
    
    UserData?: AttributeValue;
}
export declare namespace InstanceAttribute {
    
    const filterSensitiveLog: (obj: InstanceAttribute) => any;
}
export interface DescribeInstanceCreditSpecificationsRequest {
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    InstanceIds?: string[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeInstanceCreditSpecificationsRequest {
    
    const filterSensitiveLog: (obj: DescribeInstanceCreditSpecificationsRequest) => any;
}

export interface InstanceCreditSpecification {
    
    InstanceId?: string;
    
    CpuCredits?: string;
}
export declare namespace InstanceCreditSpecification {
    
    const filterSensitiveLog: (obj: InstanceCreditSpecification) => any;
}
export interface DescribeInstanceCreditSpecificationsResult {
    
    InstanceCreditSpecifications?: InstanceCreditSpecification[];
    
    NextToken?: string;
}
export declare namespace DescribeInstanceCreditSpecificationsResult {
    
    const filterSensitiveLog: (obj: DescribeInstanceCreditSpecificationsResult) => any;
}
export interface DescribeInstanceEventNotificationAttributesRequest {
    
    DryRun?: boolean;
}
export declare namespace DescribeInstanceEventNotificationAttributesRequest {
    
    const filterSensitiveLog: (obj: DescribeInstanceEventNotificationAttributesRequest) => any;
}
export interface DescribeInstanceEventNotificationAttributesResult {
    
    InstanceTagAttribute?: InstanceTagNotificationAttribute;
}
export declare namespace DescribeInstanceEventNotificationAttributesResult {
    
    const filterSensitiveLog: (obj: DescribeInstanceEventNotificationAttributesResult) => any;
}

export interface DescribeInstanceEventWindowsRequest {
    
    DryRun?: boolean;
    
    InstanceEventWindowIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeInstanceEventWindowsRequest {
    
    const filterSensitiveLog: (obj: DescribeInstanceEventWindowsRequest) => any;
}
export interface DescribeInstanceEventWindowsResult {
    
    InstanceEventWindows?: InstanceEventWindow[];
    
    NextToken?: string;
}
export declare namespace DescribeInstanceEventWindowsResult {
    
    const filterSensitiveLog: (obj: DescribeInstanceEventWindowsResult) => any;
}
export interface DescribeInstancesRequest {
    
    Filters?: Filter[];
    
    InstanceIds?: string[];
    
    DryRun?: boolean;
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeInstancesRequest {
    
    const filterSensitiveLog: (obj: DescribeInstancesRequest) => any;
}

export interface CapacityReservationSpecificationResponse {
    
    CapacityReservationPreference?: CapacityReservationPreference | string;
    
    CapacityReservationTarget?: CapacityReservationTargetResponse;
}
export declare namespace CapacityReservationSpecificationResponse {
    
    const filterSensitiveLog: (obj: CapacityReservationSpecificationResponse) => any;
}

export interface CpuOptions {
    
    CoreCount?: number;
    
    ThreadsPerCore?: number;
}
export declare namespace CpuOptions {
    
    const filterSensitiveLog: (obj: CpuOptions) => any;
}

export interface ElasticGpuAssociation {
    
    ElasticGpuId?: string;
    
    ElasticGpuAssociationId?: string;
    
    ElasticGpuAssociationState?: string;
    
    ElasticGpuAssociationTime?: string;
}
export declare namespace ElasticGpuAssociation {
    
    const filterSensitiveLog: (obj: ElasticGpuAssociation) => any;
}

export interface ElasticInferenceAcceleratorAssociation {
    
    ElasticInferenceAcceleratorArn?: string;
    
    ElasticInferenceAcceleratorAssociationId?: string;
    
    ElasticInferenceAcceleratorAssociationState?: string;
    
    ElasticInferenceAcceleratorAssociationTime?: Date;
}
export declare namespace ElasticInferenceAcceleratorAssociation {
    
    const filterSensitiveLog: (obj: ElasticInferenceAcceleratorAssociation) => any;
}

export interface HibernationOptions {
    
    Configured?: boolean;
}
export declare namespace HibernationOptions {
    
    const filterSensitiveLog: (obj: HibernationOptions) => any;
}
export declare type InstanceLifecycleType = "scheduled" | "spot";

export interface LicenseConfiguration {
    
    LicenseConfigurationArn?: string;
}
export declare namespace LicenseConfiguration {
    
    const filterSensitiveLog: (obj: LicenseConfiguration) => any;
}
export declare type InstanceMetadataEndpointState = "disabled" | "enabled";
export declare enum InstanceMetadataProtocolState {
    disabled = "disabled",
    enabled = "enabled"
}
export declare enum HttpTokensState {
    optional = "optional",
    required = "required"
}
export declare type InstanceMetadataOptionsState = "applied" | "pending";

export interface InstanceMetadataOptionsResponse {
    
    State?: InstanceMetadataOptionsState | string;
    
    HttpTokens?: HttpTokensState | string;
    
    HttpPutResponseHopLimit?: number;
    
    HttpEndpoint?: InstanceMetadataEndpointState | string;
    
    HttpProtocolIpv6?: InstanceMetadataProtocolState | string;
}
export declare namespace InstanceMetadataOptionsResponse {
    
    const filterSensitiveLog: (obj: InstanceMetadataOptionsResponse) => any;
}
export declare type MonitoringState = "disabled" | "disabling" | "enabled" | "pending";

export interface Monitoring {
    
    State?: MonitoringState | string;
}
export declare namespace Monitoring {
    
    const filterSensitiveLog: (obj: Monitoring) => any;
}

export interface InstanceNetworkInterfaceAssociation {
    
    CarrierIp?: string;
    
    CustomerOwnedIp?: string;
    
    IpOwnerId?: string;
    
    PublicDnsName?: string;
    
    PublicIp?: string;
}
export declare namespace InstanceNetworkInterfaceAssociation {
    
    const filterSensitiveLog: (obj: InstanceNetworkInterfaceAssociation) => any;
}

export interface InstanceNetworkInterfaceAttachment {
    
    AttachTime?: Date;
    
    AttachmentId?: string;
    
    DeleteOnTermination?: boolean;
    
    DeviceIndex?: number;
    
    Status?: AttachmentStatus | string;
    
    NetworkCardIndex?: number;
}
export declare namespace InstanceNetworkInterfaceAttachment {
    
    const filterSensitiveLog: (obj: InstanceNetworkInterfaceAttachment) => any;
}

export interface InstanceIpv4Prefix {
    
    Ipv4Prefix?: string;
}
export declare namespace InstanceIpv4Prefix {
    
    const filterSensitiveLog: (obj: InstanceIpv4Prefix) => any;
}

export interface InstanceIpv6Prefix {
    
    Ipv6Prefix?: string;
}
export declare namespace InstanceIpv6Prefix {
    
    const filterSensitiveLog: (obj: InstanceIpv6Prefix) => any;
}

export interface InstancePrivateIpAddress {
    
    Association?: InstanceNetworkInterfaceAssociation;
    
    Primary?: boolean;
    
    PrivateDnsName?: string;
    
    PrivateIpAddress?: string;
}
export declare namespace InstancePrivateIpAddress {
    
    const filterSensitiveLog: (obj: InstancePrivateIpAddress) => any;
}

export interface InstanceNetworkInterface {
    
    Association?: InstanceNetworkInterfaceAssociation;
    
    Attachment?: InstanceNetworkInterfaceAttachment;
    
    Description?: string;
    
    Groups?: GroupIdentifier[];
    
    Ipv6Addresses?: InstanceIpv6Address[];
    
    MacAddress?: string;
    
    NetworkInterfaceId?: string;
    
    OwnerId?: string;
    
    PrivateDnsName?: string;
    
    PrivateIpAddress?: string;
    
    PrivateIpAddresses?: InstancePrivateIpAddress[];
    
    SourceDestCheck?: boolean;
    
    Status?: NetworkInterfaceStatus | string;
    
    SubnetId?: string;
    
    VpcId?: string;
    
    InterfaceType?: string;
    
    Ipv4Prefixes?: InstanceIpv4Prefix[];
    
    Ipv6Prefixes?: InstanceIpv6Prefix[];
}
export declare namespace InstanceNetworkInterface {
    
    const filterSensitiveLog: (obj: InstanceNetworkInterface) => any;
}
export declare type InstanceStateName = "pending" | "running" | "shutting-down" | "stopped" | "stopping" | "terminated";

export interface InstanceState {
    
    Code?: number;
    
    Name?: InstanceStateName | string;
}
export declare namespace InstanceState {
    
    const filterSensitiveLog: (obj: InstanceState) => any;
}

export interface Instance {
    
    AmiLaunchIndex?: number;
    
    ImageId?: string;
    
    InstanceId?: string;
    
    InstanceType?: _InstanceType | string;
    
    KernelId?: string;
    
    KeyName?: string;
    
    LaunchTime?: Date;
    
    Monitoring?: Monitoring;
    
    Placement?: Placement;
    
    Platform?: PlatformValues | string;
    
    PrivateDnsName?: string;
    
    PrivateIpAddress?: string;
    
    ProductCodes?: ProductCode[];
    
    PublicDnsName?: string;
    
    PublicIpAddress?: string;
    
    RamdiskId?: string;
    
    State?: InstanceState;
    
    StateTransitionReason?: string;
    
    SubnetId?: string;
    
    VpcId?: string;
    
    Architecture?: ArchitectureValues | string;
    
    BlockDeviceMappings?: InstanceBlockDeviceMapping[];
    
    ClientToken?: string;
    
    EbsOptimized?: boolean;
    
    EnaSupport?: boolean;
    
    Hypervisor?: HypervisorType | string;
    
    IamInstanceProfile?: IamInstanceProfile;
    
    InstanceLifecycle?: InstanceLifecycleType | string;
    
    ElasticGpuAssociations?: ElasticGpuAssociation[];
    
    ElasticInferenceAcceleratorAssociations?: ElasticInferenceAcceleratorAssociation[];
    
    NetworkInterfaces?: InstanceNetworkInterface[];
    
    OutpostArn?: string;
    
    RootDeviceName?: string;
    
    RootDeviceType?: DeviceType | string;
    
    SecurityGroups?: GroupIdentifier[];
    
    SourceDestCheck?: boolean;
    
    SpotInstanceRequestId?: string;
    
    SriovNetSupport?: string;
    
    StateReason?: StateReason;
    
    Tags?: Tag[];
    
    VirtualizationType?: VirtualizationType | string;
    
    CpuOptions?: CpuOptions;
    
    CapacityReservationId?: string;
    
    CapacityReservationSpecification?: CapacityReservationSpecificationResponse;
    
    HibernationOptions?: HibernationOptions;
    
    Licenses?: LicenseConfiguration[];
    
    MetadataOptions?: InstanceMetadataOptionsResponse;
    
    EnclaveOptions?: EnclaveOptions;
    
    BootMode?: BootModeValues | string;
    
    PlatformDetails?: string;
    
    UsageOperation?: string;
    
    UsageOperationUpdateTime?: Date;
}
export declare namespace Instance {
    
    const filterSensitiveLog: (obj: Instance) => any;
}

export interface Reservation {
    
    Groups?: GroupIdentifier[];
    
    Instances?: Instance[];
    
    OwnerId?: string;
    
    RequesterId?: string;
    
    ReservationId?: string;
}
export declare namespace Reservation {
    
    const filterSensitiveLog: (obj: Reservation) => any;
}
export interface DescribeInstancesResult {
    
    Reservations?: Reservation[];
    
    NextToken?: string;
}
export declare namespace DescribeInstancesResult {
    
    const filterSensitiveLog: (obj: DescribeInstancesResult) => any;
}
export interface DescribeInstanceStatusRequest {
    
    Filters?: Filter[];
    
    InstanceIds?: string[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
    
    IncludeAllInstances?: boolean;
}
export declare namespace DescribeInstanceStatusRequest {
    
    const filterSensitiveLog: (obj: DescribeInstanceStatusRequest) => any;
}
export declare type EventCode = "instance-reboot" | "instance-retirement" | "instance-stop" | "system-maintenance" | "system-reboot";

export interface InstanceStatusEvent {
    
    InstanceEventId?: string;
    
    Code?: EventCode | string;
    
    Description?: string;
    
    NotAfter?: Date;
    
    NotBefore?: Date;
    
    NotBeforeDeadline?: Date;
}
export declare namespace InstanceStatusEvent {
    
    const filterSensitiveLog: (obj: InstanceStatusEvent) => any;
}
export declare type StatusName = "reachability";
export declare type StatusType = "failed" | "initializing" | "insufficient-data" | "passed";

export interface InstanceStatusDetails {
    
    ImpairedSince?: Date;
    
    Name?: StatusName | string;
    
    Status?: StatusType | string;
}
export declare namespace InstanceStatusDetails {
    
    const filterSensitiveLog: (obj: InstanceStatusDetails) => any;
}
export declare type SummaryStatus = "impaired" | "initializing" | "insufficient-data" | "not-applicable" | "ok";

export interface InstanceStatusSummary {
    
    Details?: InstanceStatusDetails[];
    
    Status?: SummaryStatus | string;
}
export declare namespace InstanceStatusSummary {
    
    const filterSensitiveLog: (obj: InstanceStatusSummary) => any;
}

export interface InstanceStatus {
    
    AvailabilityZone?: string;
    
    OutpostArn?: string;
    
    Events?: InstanceStatusEvent[];
    
    InstanceId?: string;
    
    InstanceState?: InstanceState;
    
    InstanceStatus?: InstanceStatusSummary;
    
    SystemStatus?: InstanceStatusSummary;
}
export declare namespace InstanceStatus {
    
    const filterSensitiveLog: (obj: InstanceStatus) => any;
}
export interface DescribeInstanceStatusResult {
    
    InstanceStatuses?: InstanceStatus[];
    
    NextToken?: string;
}
export declare namespace DescribeInstanceStatusResult {
    
    const filterSensitiveLog: (obj: DescribeInstanceStatusResult) => any;
}
export declare type LocationType = "availability-zone" | "availability-zone-id" | "region";
export interface DescribeInstanceTypeOfferingsRequest {
    
    DryRun?: boolean;
    
    LocationType?: LocationType | string;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeInstanceTypeOfferingsRequest {
    
    const filterSensitiveLog: (obj: DescribeInstanceTypeOfferingsRequest) => any;
}

export interface InstanceTypeOffering {
    
    InstanceType?: _InstanceType | string;
    
    LocationType?: LocationType | string;
    
    Location?: string;
}
export declare namespace InstanceTypeOffering {
    
    const filterSensitiveLog: (obj: InstanceTypeOffering) => any;
}
export interface DescribeInstanceTypeOfferingsResult {
    
    InstanceTypeOfferings?: InstanceTypeOffering[];
    
    NextToken?: string;
}
export declare namespace DescribeInstanceTypeOfferingsResult {
    
    const filterSensitiveLog: (obj: DescribeInstanceTypeOfferingsResult) => any;
}
export interface DescribeInstanceTypesRequest {
    
    DryRun?: boolean;
    
    InstanceTypes?: (_InstanceType | string)[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeInstanceTypesRequest {
    
    const filterSensitiveLog: (obj: DescribeInstanceTypesRequest) => any;
}

export interface EbsOptimizedInfo {
    
    BaselineBandwidthInMbps?: number;
    
    BaselineThroughputInMBps?: number;
    
    BaselineIops?: number;
    
    MaximumBandwidthInMbps?: number;
    
    MaximumThroughputInMBps?: number;
    
    MaximumIops?: number;
}
export declare namespace EbsOptimizedInfo {
    
    const filterSensitiveLog: (obj: EbsOptimizedInfo) => any;
}
export declare type EbsOptimizedSupport = "default" | "supported" | "unsupported";
export declare type EbsEncryptionSupport = "supported" | "unsupported";
export declare enum EbsNvmeSupport {
    REQUIRED = "required",
    SUPPORTED = "supported",
    UNSUPPORTED = "unsupported"
}

export interface EbsInfo {
    
    EbsOptimizedSupport?: EbsOptimizedSupport | string;
    
    EncryptionSupport?: EbsEncryptionSupport | string;
    
    EbsOptimizedInfo?: EbsOptimizedInfo;
    
    NvmeSupport?: EbsNvmeSupport | string;
}
export declare namespace EbsInfo {
    
    const filterSensitiveLog: (obj: EbsInfo) => any;
}

export interface FpgaDeviceMemoryInfo {
    
    SizeInMiB?: number;
}
export declare namespace FpgaDeviceMemoryInfo {
    
    const filterSensitiveLog: (obj: FpgaDeviceMemoryInfo) => any;
}

export interface FpgaDeviceInfo {
    
    Name?: string;
    
    Manufacturer?: string;
    
    Count?: number;
    
    MemoryInfo?: FpgaDeviceMemoryInfo;
}
export declare namespace FpgaDeviceInfo {
    
    const filterSensitiveLog: (obj: FpgaDeviceInfo) => any;
}

export interface FpgaInfo {
    
    Fpgas?: FpgaDeviceInfo[];
    
    TotalFpgaMemoryInMiB?: number;
}
export declare namespace FpgaInfo {
    
    const filterSensitiveLog: (obj: FpgaInfo) => any;
}

export interface GpuDeviceMemoryInfo {
    
    SizeInMiB?: number;
}
export declare namespace GpuDeviceMemoryInfo {
    
    const filterSensitiveLog: (obj: GpuDeviceMemoryInfo) => any;
}

export interface GpuDeviceInfo {
    
    Name?: string;
    
    Manufacturer?: string;
    
    Count?: number;
    
    MemoryInfo?: GpuDeviceMemoryInfo;
}
export declare namespace GpuDeviceInfo {
    
    const filterSensitiveLog: (obj: GpuDeviceInfo) => any;
}

export interface GpuInfo {
    
    Gpus?: GpuDeviceInfo[];
    
    TotalGpuMemoryInMiB?: number;
}
export declare namespace GpuInfo {
    
    const filterSensitiveLog: (obj: GpuInfo) => any;
}
export declare enum InstanceTypeHypervisor {
    NITRO = "nitro",
    XEN = "xen"
}

export interface InferenceDeviceInfo {
    
    Count?: number;
    
    Name?: string;
    
    Manufacturer?: string;
}
export declare namespace InferenceDeviceInfo {
    
    const filterSensitiveLog: (obj: InferenceDeviceInfo) => any;
}

export interface InferenceAcceleratorInfo {
    
    Accelerators?: InferenceDeviceInfo[];
}
export declare namespace InferenceAcceleratorInfo {
    
    const filterSensitiveLog: (obj: InferenceAcceleratorInfo) => any;
}
export declare type DiskType = "hdd" | "ssd";

export interface DiskInfo {
    
    SizeInGB?: number;
    
    Count?: number;
    
    Type?: DiskType | string;
}
export declare namespace DiskInfo {
    
    const filterSensitiveLog: (obj: DiskInfo) => any;
}
export declare enum InstanceStorageEncryptionSupport {
    required = "required",
    unsupported = "unsupported"
}
export declare enum EphemeralNvmeSupport {
    REQUIRED = "required",
    SUPPORTED = "supported",
    UNSUPPORTED = "unsupported"
}

export interface InstanceStorageInfo {
    
    TotalSizeInGB?: number;
    
    Disks?: DiskInfo[];
    
    NvmeSupport?: EphemeralNvmeSupport | string;
    
    EncryptionSupport?: InstanceStorageEncryptionSupport | string;
}
export declare namespace InstanceStorageInfo {
    
    const filterSensitiveLog: (obj: InstanceStorageInfo) => any;
}

export interface MemoryInfo {
    
    SizeInMiB?: number;
}
export declare namespace MemoryInfo {
    
    const filterSensitiveLog: (obj: MemoryInfo) => any;
}

export interface EfaInfo {
    
    MaximumEfaInterfaces?: number;
}
export declare namespace EfaInfo {
    
    const filterSensitiveLog: (obj: EfaInfo) => any;
}
export declare type EnaSupport = "required" | "supported" | "unsupported";

export interface NetworkCardInfo {
    
    NetworkCardIndex?: number;
    
    NetworkPerformance?: string;
    
    MaximumNetworkInterfaces?: number;
}
export declare namespace NetworkCardInfo {
    
    const filterSensitiveLog: (obj: NetworkCardInfo) => any;
}

export interface NetworkInfo {
    
    NetworkPerformance?: string;
    
    MaximumNetworkInterfaces?: number;
    
    MaximumNetworkCards?: number;
    
    DefaultNetworkCardIndex?: number;
    
    NetworkCards?: NetworkCardInfo[];
    
    Ipv4AddressesPerInterface?: number;
    
    Ipv6AddressesPerInterface?: number;
    
    Ipv6Supported?: boolean;
    
    EnaSupport?: EnaSupport | string;
    
    EfaSupported?: boolean;
    
    EfaInfo?: EfaInfo;
    
    EncryptionInTransitSupported?: boolean;
}
export declare namespace NetworkInfo {
    
    const filterSensitiveLog: (obj: NetworkInfo) => any;
}
export declare type PlacementGroupStrategy = "cluster" | "partition" | "spread";

export interface PlacementGroupInfo {
    
    SupportedStrategies?: (PlacementGroupStrategy | string)[];
}
export declare namespace PlacementGroupInfo {
    
    const filterSensitiveLog: (obj: PlacementGroupInfo) => any;
}
export declare type ArchitectureType = "arm64" | "i386" | "x86_64" | "x86_64_mac";

export interface ProcessorInfo {
    
    SupportedArchitectures?: (ArchitectureType | string)[];
    
    SustainedClockSpeedInGhz?: number;
}
export declare namespace ProcessorInfo {
    
    const filterSensitiveLog: (obj: ProcessorInfo) => any;
}
export declare type BootModeType = "legacy-bios" | "uefi";
export declare type RootDeviceType = "ebs" | "instance-store";
export declare type UsageClassType = "on-demand" | "spot";

export interface VCpuInfo {
    
    DefaultVCpus?: number;
    
    DefaultCores?: number;
    
    DefaultThreadsPerCore?: number;
    
    ValidCores?: number[];
    
    ValidThreadsPerCore?: number[];
}
export declare namespace VCpuInfo {
    
    const filterSensitiveLog: (obj: VCpuInfo) => any;
}

export interface InstanceTypeInfo {
    
    InstanceType?: _InstanceType | string;
    
    CurrentGeneration?: boolean;
    
    FreeTierEligible?: boolean;
    
    SupportedUsageClasses?: (UsageClassType | string)[];
    
    SupportedRootDeviceTypes?: (RootDeviceType | string)[];
    
    SupportedVirtualizationTypes?: (VirtualizationType | string)[];
    
    BareMetal?: boolean;
    
    Hypervisor?: InstanceTypeHypervisor | string;
    
    ProcessorInfo?: ProcessorInfo;
    
    VCpuInfo?: VCpuInfo;
    
    MemoryInfo?: MemoryInfo;
    
    InstanceStorageSupported?: boolean;
    
    InstanceStorageInfo?: InstanceStorageInfo;
    
    EbsInfo?: EbsInfo;
    
    NetworkInfo?: NetworkInfo;
    
    GpuInfo?: GpuInfo;
    
    FpgaInfo?: FpgaInfo;
    
    PlacementGroupInfo?: PlacementGroupInfo;
    
    InferenceAcceleratorInfo?: InferenceAcceleratorInfo;
    
    HibernationSupported?: boolean;
    
    BurstablePerformanceSupported?: boolean;
    
    DedicatedHostsSupported?: boolean;
    
    AutoRecoverySupported?: boolean;
    
    SupportedBootModes?: (BootModeType | string)[];
}
export declare namespace InstanceTypeInfo {
    
    const filterSensitiveLog: (obj: InstanceTypeInfo) => any;
}
export interface DescribeInstanceTypesResult {
    
    InstanceTypes?: InstanceTypeInfo[];
    
    NextToken?: string;
}
export declare namespace DescribeInstanceTypesResult {
    
    const filterSensitiveLog: (obj: DescribeInstanceTypesResult) => any;
}
export interface DescribeInternetGatewaysRequest {
    
    Filters?: Filter[];
    
    DryRun?: boolean;
    
    InternetGatewayIds?: string[];
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeInternetGatewaysRequest {
    
    const filterSensitiveLog: (obj: DescribeInternetGatewaysRequest) => any;
}
export interface DescribeInternetGatewaysResult {
    
    InternetGateways?: InternetGateway[];
    
    NextToken?: string;
}
export declare namespace DescribeInternetGatewaysResult {
    
    const filterSensitiveLog: (obj: DescribeInternetGatewaysResult) => any;
}
export interface DescribeIpv6PoolsRequest {
    
    PoolIds?: string[];
    
    NextToken?: string;
    
    MaxResults?: number;
    
    DryRun?: boolean;
    
    Filters?: Filter[];
}
export declare namespace DescribeIpv6PoolsRequest {
    
    const filterSensitiveLog: (obj: DescribeIpv6PoolsRequest) => any;
}

export interface PoolCidrBlock {
    
    Cidr?: string;
}
export declare namespace PoolCidrBlock {
    
    const filterSensitiveLog: (obj: PoolCidrBlock) => any;
}

export interface Ipv6Pool {
    
    PoolId?: string;
    
    Description?: string;
    
    PoolCidrBlocks?: PoolCidrBlock[];
    
    Tags?: Tag[];
}
export declare namespace Ipv6Pool {
    
    const filterSensitiveLog: (obj: Ipv6Pool) => any;
}
export interface DescribeIpv6PoolsResult {
    
    Ipv6Pools?: Ipv6Pool[];
    
    NextToken?: string;
}
export declare namespace DescribeIpv6PoolsResult {
    
    const filterSensitiveLog: (obj: DescribeIpv6PoolsResult) => any;
}
export interface DescribeKeyPairsRequest {
    
    Filters?: Filter[];
    
    KeyNames?: string[];
    
    KeyPairIds?: string[];
    
    DryRun?: boolean;
}
export declare namespace DescribeKeyPairsRequest {
    
    const filterSensitiveLog: (obj: DescribeKeyPairsRequest) => any;
}

export interface KeyPairInfo {
    
    KeyPairId?: string;
    
    KeyFingerprint?: string;
    
    KeyName?: string;
    
    KeyType?: KeyType | string;
    
    Tags?: Tag[];
}
export declare namespace KeyPairInfo {
    
    const filterSensitiveLog: (obj: KeyPairInfo) => any;
}
export interface DescribeKeyPairsResult {
    
    KeyPairs?: KeyPairInfo[];
}
export declare namespace DescribeKeyPairsResult {
    
    const filterSensitiveLog: (obj: DescribeKeyPairsResult) => any;
}
export interface DescribeLaunchTemplatesRequest {
    
    DryRun?: boolean;
    
    LaunchTemplateIds?: string[];
    
    LaunchTemplateNames?: string[];
    
    Filters?: Filter[];
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeLaunchTemplatesRequest {
    
    const filterSensitiveLog: (obj: DescribeLaunchTemplatesRequest) => any;
}
export interface DescribeLaunchTemplatesResult {
    
    LaunchTemplates?: LaunchTemplate[];
    
    NextToken?: string;
}
export declare namespace DescribeLaunchTemplatesResult {
    
    const filterSensitiveLog: (obj: DescribeLaunchTemplatesResult) => any;
}
export interface DescribeLaunchTemplateVersionsRequest {
    
    DryRun?: boolean;
    
    LaunchTemplateId?: string;
    
    LaunchTemplateName?: string;
    
    Versions?: string[];
    
    MinVersion?: string;
    
    MaxVersion?: string;
    
    NextToken?: string;
    
    MaxResults?: number;
    
    Filters?: Filter[];
}
export declare namespace DescribeLaunchTemplateVersionsRequest {
    
    const filterSensitiveLog: (obj: DescribeLaunchTemplateVersionsRequest) => any;
}
export interface DescribeLaunchTemplateVersionsResult {
    
    LaunchTemplateVersions?: LaunchTemplateVersion[];
    
    NextToken?: string;
}
export declare namespace DescribeLaunchTemplateVersionsResult {
    
    const filterSensitiveLog: (obj: DescribeLaunchTemplateVersionsResult) => any;
}
export interface DescribeLocalGatewayRouteTablesRequest {
    
    LocalGatewayRouteTableIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeLocalGatewayRouteTablesRequest {
    
    const filterSensitiveLog: (obj: DescribeLocalGatewayRouteTablesRequest) => any;
}

export interface LocalGatewayRouteTable {
    
    LocalGatewayRouteTableId?: string;
    
    LocalGatewayRouteTableArn?: string;
    
    LocalGatewayId?: string;
    
    OutpostArn?: string;
    
    OwnerId?: string;
    
    State?: string;
    
    Tags?: Tag[];
}
export declare namespace LocalGatewayRouteTable {
    
    const filterSensitiveLog: (obj: LocalGatewayRouteTable) => any;
}
export interface DescribeLocalGatewayRouteTablesResult {
    
    LocalGatewayRouteTables?: LocalGatewayRouteTable[];
    
    NextToken?: string;
}
export declare namespace DescribeLocalGatewayRouteTablesResult {
    
    const filterSensitiveLog: (obj: DescribeLocalGatewayRouteTablesResult) => any;
}
export interface DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest {
    
    LocalGatewayRouteTableVirtualInterfaceGroupAssociationIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest {
    
    const filterSensitiveLog: (obj: DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest) => any;
}

export interface LocalGatewayRouteTableVirtualInterfaceGroupAssociation {
    
    LocalGatewayRouteTableVirtualInterfaceGroupAssociationId?: string;
    
    LocalGatewayVirtualInterfaceGroupId?: string;
    
    LocalGatewayId?: string;
    
    LocalGatewayRouteTableId?: string;
    
    LocalGatewayRouteTableArn?: string;
    
    OwnerId?: string;
    
    State?: string;
    
    Tags?: Tag[];
}
export declare namespace LocalGatewayRouteTableVirtualInterfaceGroupAssociation {
    
    const filterSensitiveLog: (obj: LocalGatewayRouteTableVirtualInterfaceGroupAssociation) => any;
}
export interface DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResult {
    
    LocalGatewayRouteTableVirtualInterfaceGroupAssociations?: LocalGatewayRouteTableVirtualInterfaceGroupAssociation[];
    
    NextToken?: string;
}
export declare namespace DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResult {
    
    const filterSensitiveLog: (obj: DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResult) => any;
}
export interface DescribeLocalGatewayRouteTableVpcAssociationsRequest {
    
    LocalGatewayRouteTableVpcAssociationIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeLocalGatewayRouteTableVpcAssociationsRequest {
    
    const filterSensitiveLog: (obj: DescribeLocalGatewayRouteTableVpcAssociationsRequest) => any;
}
export interface DescribeLocalGatewayRouteTableVpcAssociationsResult {
    
    LocalGatewayRouteTableVpcAssociations?: LocalGatewayRouteTableVpcAssociation[];
    
    NextToken?: string;
}
export declare namespace DescribeLocalGatewayRouteTableVpcAssociationsResult {
    
    const filterSensitiveLog: (obj: DescribeLocalGatewayRouteTableVpcAssociationsResult) => any;
}
export interface DescribeLocalGatewaysRequest {
    
    LocalGatewayIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeLocalGatewaysRequest {
    
    const filterSensitiveLog: (obj: DescribeLocalGatewaysRequest) => any;
}

export interface LocalGateway {
    
    LocalGatewayId?: string;
    
    OutpostArn?: string;
    
    OwnerId?: string;
    
    State?: string;
    
    Tags?: Tag[];
}
export declare namespace LocalGateway {
    
    const filterSensitiveLog: (obj: LocalGateway) => any;
}
export interface DescribeLocalGatewaysResult {
    
    LocalGateways?: LocalGateway[];
    
    NextToken?: string;
}
export declare namespace DescribeLocalGatewaysResult {
    
    const filterSensitiveLog: (obj: DescribeLocalGatewaysResult) => any;
}
export interface DescribeLocalGatewayVirtualInterfaceGroupsRequest {
    
    LocalGatewayVirtualInterfaceGroupIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeLocalGatewayVirtualInterfaceGroupsRequest {
    
    const filterSensitiveLog: (obj: DescribeLocalGatewayVirtualInterfaceGroupsRequest) => any;
}

export interface LocalGatewayVirtualInterfaceGroup {
    
    LocalGatewayVirtualInterfaceGroupId?: string;
    
    LocalGatewayVirtualInterfaceIds?: string[];
    
    LocalGatewayId?: string;
    
    OwnerId?: string;
    
    Tags?: Tag[];
}
export declare namespace LocalGatewayVirtualInterfaceGroup {
    
    const filterSensitiveLog: (obj: LocalGatewayVirtualInterfaceGroup) => any;
}
export interface DescribeLocalGatewayVirtualInterfaceGroupsResult {
    
    LocalGatewayVirtualInterfaceGroups?: LocalGatewayVirtualInterfaceGroup[];
    
    NextToken?: string;
}
export declare namespace DescribeLocalGatewayVirtualInterfaceGroupsResult {
    
    const filterSensitiveLog: (obj: DescribeLocalGatewayVirtualInterfaceGroupsResult) => any;
}
export interface DescribeLocalGatewayVirtualInterfacesRequest {
    
    LocalGatewayVirtualInterfaceIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeLocalGatewayVirtualInterfacesRequest {
    
    const filterSensitiveLog: (obj: DescribeLocalGatewayVirtualInterfacesRequest) => any;
}

export interface LocalGatewayVirtualInterface {
    
    LocalGatewayVirtualInterfaceId?: string;
    
    LocalGatewayId?: string;
    
    Vlan?: number;
    
    LocalAddress?: string;
    
    PeerAddress?: string;
    
    LocalBgpAsn?: number;
    
    PeerBgpAsn?: number;
    
    OwnerId?: string;
    
    Tags?: Tag[];
}
export declare namespace LocalGatewayVirtualInterface {
    
    const filterSensitiveLog: (obj: LocalGatewayVirtualInterface) => any;
}
export interface DescribeLocalGatewayVirtualInterfacesResult {
    
    LocalGatewayVirtualInterfaces?: LocalGatewayVirtualInterface[];
    
    NextToken?: string;
}
export declare namespace DescribeLocalGatewayVirtualInterfacesResult {
    
    const filterSensitiveLog: (obj: DescribeLocalGatewayVirtualInterfacesResult) => any;
}
export interface DescribeManagedPrefixListsRequest {
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    PrefixListIds?: string[];
}
export declare namespace DescribeManagedPrefixListsRequest {
    
    const filterSensitiveLog: (obj: DescribeManagedPrefixListsRequest) => any;
}
export interface DescribeManagedPrefixListsResult {
    
    NextToken?: string;
    
    PrefixLists?: ManagedPrefixList[];
}
export declare namespace DescribeManagedPrefixListsResult {
    
    const filterSensitiveLog: (obj: DescribeManagedPrefixListsResult) => any;
}
export interface DescribeMovingAddressesRequest {
    
    Filters?: Filter[];
    
    DryRun?: boolean;
    
    MaxResults?: number;
    
    NextToken?: string;
    
    PublicIps?: string[];
}
export declare namespace DescribeMovingAddressesRequest {
    
    const filterSensitiveLog: (obj: DescribeMovingAddressesRequest) => any;
}
export declare type MoveStatus = "movingToVpc" | "restoringToClassic";

export interface MovingAddressStatus {
    
    MoveStatus?: MoveStatus | string;
    
    PublicIp?: string;
}
export declare namespace MovingAddressStatus {
    
    const filterSensitiveLog: (obj: MovingAddressStatus) => any;
}
export interface DescribeMovingAddressesResult {
    
    MovingAddressStatuses?: MovingAddressStatus[];
    
    NextToken?: string;
}
export declare namespace DescribeMovingAddressesResult {
    
    const filterSensitiveLog: (obj: DescribeMovingAddressesResult) => any;
}
export interface DescribeNatGatewaysRequest {
    
    DryRun?: boolean;
    
    Filter?: Filter[];
    
    MaxResults?: number;
    
    NatGatewayIds?: string[];
    
    NextToken?: string;
}
export declare namespace DescribeNatGatewaysRequest {
    
    const filterSensitiveLog: (obj: DescribeNatGatewaysRequest) => any;
}
export interface DescribeNatGatewaysResult {
    
    NatGateways?: NatGateway[];
    
    NextToken?: string;
}
export declare namespace DescribeNatGatewaysResult {
    
    const filterSensitiveLog: (obj: DescribeNatGatewaysResult) => any;
}
export interface DescribeNetworkAclsRequest {
    
    Filters?: Filter[];
    
    DryRun?: boolean;
    
    NetworkAclIds?: string[];
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeNetworkAclsRequest {
    
    const filterSensitiveLog: (obj: DescribeNetworkAclsRequest) => any;
}
export interface DescribeNetworkAclsResult {
    
    NetworkAcls?: NetworkAcl[];
    
    NextToken?: string;
}
export declare namespace DescribeNetworkAclsResult {
    
    const filterSensitiveLog: (obj: DescribeNetworkAclsResult) => any;
}
export interface DescribeNetworkInsightsAnalysesRequest {
    
    NetworkInsightsAnalysisIds?: string[];
    
    NetworkInsightsPathId?: string;
    
    AnalysisStartTime?: Date;
    
    AnalysisEndTime?: Date;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    DryRun?: boolean;
    
    NextToken?: string;
}
export declare namespace DescribeNetworkInsightsAnalysesRequest {
    
    const filterSensitiveLog: (obj: DescribeNetworkInsightsAnalysesRequest) => any;
}

export interface AnalysisComponent {
    
    Id?: string;
    
    Arn?: string;
}
export declare namespace AnalysisComponent {
    
    const filterSensitiveLog: (obj: AnalysisComponent) => any;
}

export interface AnalysisAclRule {
    
    Cidr?: string;
    
    Egress?: boolean;
    
    PortRange?: PortRange;
    
    Protocol?: string;
    
    RuleAction?: string;
    
    RuleNumber?: number;
}
export declare namespace AnalysisAclRule {
    
    const filterSensitiveLog: (obj: AnalysisAclRule) => any;
}

export interface AnalysisLoadBalancerListener {
    
    LoadBalancerPort?: number;
    
    InstancePort?: number;
}
export declare namespace AnalysisLoadBalancerListener {
    
    const filterSensitiveLog: (obj: AnalysisLoadBalancerListener) => any;
}

export interface AnalysisLoadBalancerTarget {
    
    Address?: string;
    
    AvailabilityZone?: string;
    
    Instance?: AnalysisComponent;
    
    Port?: number;
}
export declare namespace AnalysisLoadBalancerTarget {
    
    const filterSensitiveLog: (obj: AnalysisLoadBalancerTarget) => any;
}

export interface AnalysisRouteTableRoute {
    
    DestinationCidr?: string;
    
    DestinationPrefixListId?: string;
    
    EgressOnlyInternetGatewayId?: string;
    
    GatewayId?: string;
    
    InstanceId?: string;
    
    NatGatewayId?: string;
    
    NetworkInterfaceId?: string;
    
    Origin?: string;
    
    TransitGatewayId?: string;
    
    VpcPeeringConnectionId?: string;
}
export declare namespace AnalysisRouteTableRoute {
    
    const filterSensitiveLog: (obj: AnalysisRouteTableRoute) => any;
}

export interface AnalysisSecurityGroupRule {
    
    Cidr?: string;
    
    Direction?: string;
    
    SecurityGroupId?: string;
    
    PortRange?: PortRange;
    
    PrefixListId?: string;
    
    Protocol?: string;
}
export declare namespace AnalysisSecurityGroupRule {
    
    const filterSensitiveLog: (obj: AnalysisSecurityGroupRule) => any;
}

export interface Explanation {
    
    Acl?: AnalysisComponent;
    
    AclRule?: AnalysisAclRule;
    
    Address?: string;
    
    Addresses?: string[];
    
    AttachedTo?: AnalysisComponent;
    
    AvailabilityZones?: string[];
    
    Cidrs?: string[];
    
    Component?: AnalysisComponent;
    
    CustomerGateway?: AnalysisComponent;
    
    Destination?: AnalysisComponent;
    
    DestinationVpc?: AnalysisComponent;
    
    Direction?: string;
    
    ExplanationCode?: string;
    
    IngressRouteTable?: AnalysisComponent;
    
    InternetGateway?: AnalysisComponent;
    
    LoadBalancerArn?: string;
    
    ClassicLoadBalancerListener?: AnalysisLoadBalancerListener;
    
    LoadBalancerListenerPort?: number;
    
    LoadBalancerTarget?: AnalysisLoadBalancerTarget;
    
    LoadBalancerTargetGroup?: AnalysisComponent;
    
    LoadBalancerTargetGroups?: AnalysisComponent[];
    
    LoadBalancerTargetPort?: number;
    
    ElasticLoadBalancerListener?: AnalysisComponent;
    
    MissingComponent?: string;
    
    NatGateway?: AnalysisComponent;
    
    NetworkInterface?: AnalysisComponent;
    
    PacketField?: string;
    
    VpcPeeringConnection?: AnalysisComponent;
    
    Port?: number;
    
    PortRanges?: PortRange[];
    
    PrefixList?: AnalysisComponent;
    
    Protocols?: string[];
    
    RouteTableRoute?: AnalysisRouteTableRoute;
    
    RouteTable?: AnalysisComponent;
    
    SecurityGroup?: AnalysisComponent;
    
    SecurityGroupRule?: AnalysisSecurityGroupRule;
    
    SecurityGroups?: AnalysisComponent[];
    
    SourceVpc?: AnalysisComponent;
    
    State?: string;
    
    Subnet?: AnalysisComponent;
    
    SubnetRouteTable?: AnalysisComponent;
    
    Vpc?: AnalysisComponent;
    
    VpcEndpoint?: AnalysisComponent;
    
    VpnConnection?: AnalysisComponent;
    
    VpnGateway?: AnalysisComponent;
}
export declare namespace Explanation {
    
    const filterSensitiveLog: (obj: Explanation) => any;
}

export interface AnalysisPacketHeader {
    
    DestinationAddresses?: string[];
    
    DestinationPortRanges?: PortRange[];
    
    Protocol?: string;
    
    SourceAddresses?: string[];
    
    SourcePortRanges?: PortRange[];
}
export declare namespace AnalysisPacketHeader {
    
    const filterSensitiveLog: (obj: AnalysisPacketHeader) => any;
}

export interface PathComponent {
    
    SequenceNumber?: number;
    
    AclRule?: AnalysisAclRule;
    
    Component?: AnalysisComponent;
    
    DestinationVpc?: AnalysisComponent;
    
    OutboundHeader?: AnalysisPacketHeader;
    
    InboundHeader?: AnalysisPacketHeader;
    
    RouteTableRoute?: AnalysisRouteTableRoute;
    
    SecurityGroupRule?: AnalysisSecurityGroupRule;
    
    SourceVpc?: AnalysisComponent;
    
    Subnet?: AnalysisComponent;
    
    Vpc?: AnalysisComponent;
}
export declare namespace PathComponent {
    
    const filterSensitiveLog: (obj: PathComponent) => any;
}
export declare type AnalysisStatus = "failed" | "running" | "succeeded";

export interface NetworkInsightsAnalysis {
    
    NetworkInsightsAnalysisId?: string;
    
    NetworkInsightsAnalysisArn?: string;
    
    NetworkInsightsPathId?: string;
    
    FilterInArns?: string[];
    
    StartDate?: Date;
    
    Status?: AnalysisStatus | string;
    
    StatusMessage?: string;
    
    NetworkPathFound?: boolean;
    
    ForwardPathComponents?: PathComponent[];
    
    ReturnPathComponents?: PathComponent[];
    
    Explanations?: Explanation[];
    
    AlternatePathHints?: AlternatePathHint[];
    
    Tags?: Tag[];
}
export declare namespace NetworkInsightsAnalysis {
    
    const filterSensitiveLog: (obj: NetworkInsightsAnalysis) => any;
}
export interface DescribeNetworkInsightsAnalysesResult {
    
    NetworkInsightsAnalyses?: NetworkInsightsAnalysis[];
    
    NextToken?: string;
}
export declare namespace DescribeNetworkInsightsAnalysesResult {
    
    const filterSensitiveLog: (obj: DescribeNetworkInsightsAnalysesResult) => any;
}
export interface DescribeNetworkInsightsPathsRequest {
    
    NetworkInsightsPathIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    DryRun?: boolean;
    
    NextToken?: string;
}
export declare namespace DescribeNetworkInsightsPathsRequest {
    
    const filterSensitiveLog: (obj: DescribeNetworkInsightsPathsRequest) => any;
}
export interface DescribeNetworkInsightsPathsResult {
    
    NetworkInsightsPaths?: NetworkInsightsPath[];
    
    NextToken?: string;
}
export declare namespace DescribeNetworkInsightsPathsResult {
    
    const filterSensitiveLog: (obj: DescribeNetworkInsightsPathsResult) => any;
}
export declare type NetworkInterfaceAttribute = "attachment" | "description" | "groupSet" | "sourceDestCheck";

export interface DescribeNetworkInterfaceAttributeRequest {
    
    Attribute?: NetworkInterfaceAttribute | string;
    
    DryRun?: boolean;
    
    NetworkInterfaceId: string | undefined;
}
export declare namespace DescribeNetworkInterfaceAttributeRequest {
    
    const filterSensitiveLog: (obj: DescribeNetworkInterfaceAttributeRequest) => any;
}

export interface DescribeNetworkInterfaceAttributeResult {
    
    Attachment?: NetworkInterfaceAttachment;
    
    Description?: AttributeValue;
    
    Groups?: GroupIdentifier[];
    
    NetworkInterfaceId?: string;
    
    SourceDestCheck?: AttributeBooleanValue;
}
export declare namespace DescribeNetworkInterfaceAttributeResult {
    
    const filterSensitiveLog: (obj: DescribeNetworkInterfaceAttributeResult) => any;
}

export interface DescribeNetworkInterfacePermissionsRequest {
    
    NetworkInterfacePermissionIds?: string[];
    
    Filters?: Filter[];
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeNetworkInterfacePermissionsRequest {
    
    const filterSensitiveLog: (obj: DescribeNetworkInterfacePermissionsRequest) => any;
}

export interface DescribeNetworkInterfacePermissionsResult {
    
    NetworkInterfacePermissions?: NetworkInterfacePermission[];
    
    NextToken?: string;
}
export declare namespace DescribeNetworkInterfacePermissionsResult {
    
    const filterSensitiveLog: (obj: DescribeNetworkInterfacePermissionsResult) => any;
}

export interface DescribeNetworkInterfacesRequest {
    
    Filters?: Filter[];
    
    DryRun?: boolean;
    
    NetworkInterfaceIds?: string[];
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeNetworkInterfacesRequest {
    
    const filterSensitiveLog: (obj: DescribeNetworkInterfacesRequest) => any;
}

export interface DescribeNetworkInterfacesResult {
    
    NetworkInterfaces?: NetworkInterface[];
    
    NextToken?: string;
}
export declare namespace DescribeNetworkInterfacesResult {
    
    const filterSensitiveLog: (obj: DescribeNetworkInterfacesResult) => any;
}
export interface DescribePlacementGroupsRequest {
    
    Filters?: Filter[];
    
    DryRun?: boolean;
    
    GroupNames?: string[];
    
    GroupIds?: string[];
}
export declare namespace DescribePlacementGroupsRequest {
    
    const filterSensitiveLog: (obj: DescribePlacementGroupsRequest) => any;
}
export interface DescribePlacementGroupsResult {
    
    PlacementGroups?: PlacementGroup[];
}
export declare namespace DescribePlacementGroupsResult {
    
    const filterSensitiveLog: (obj: DescribePlacementGroupsResult) => any;
}
export interface DescribePrefixListsRequest {
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    PrefixListIds?: string[];
}
export declare namespace DescribePrefixListsRequest {
    
    const filterSensitiveLog: (obj: DescribePrefixListsRequest) => any;
}

export interface PrefixList {
    
    Cidrs?: string[];
    
    PrefixListId?: string;
    
    PrefixListName?: string;
}
export declare namespace PrefixList {
    
    const filterSensitiveLog: (obj: PrefixList) => any;
}
export interface DescribePrefixListsResult {
    
    NextToken?: string;
    
    PrefixLists?: PrefixList[];
}
export declare namespace DescribePrefixListsResult {
    
    const filterSensitiveLog: (obj: DescribePrefixListsResult) => any;
}
export interface DescribePrincipalIdFormatRequest {
    
    DryRun?: boolean;
    
    Resources?: string[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribePrincipalIdFormatRequest {
    
    const filterSensitiveLog: (obj: DescribePrincipalIdFormatRequest) => any;
}

export interface PrincipalIdFormat {
    
    Arn?: string;
    
    Statuses?: IdFormat[];
}
export declare namespace PrincipalIdFormat {
    
    const filterSensitiveLog: (obj: PrincipalIdFormat) => any;
}
export interface DescribePrincipalIdFormatResult {
    
    Principals?: PrincipalIdFormat[];
    
    NextToken?: string;
}
export declare namespace DescribePrincipalIdFormatResult {
    
    const filterSensitiveLog: (obj: DescribePrincipalIdFormatResult) => any;
}
export interface DescribePublicIpv4PoolsRequest {
    
    PoolIds?: string[];
    
    NextToken?: string;
    
    MaxResults?: number;
    
    Filters?: Filter[];
}
export declare namespace DescribePublicIpv4PoolsRequest {
    
    const filterSensitiveLog: (obj: DescribePublicIpv4PoolsRequest) => any;
}

export interface PublicIpv4PoolRange {
    
    FirstAddress?: string;
    
    LastAddress?: string;
    
    AddressCount?: number;
    
    AvailableAddressCount?: number;
}
export declare namespace PublicIpv4PoolRange {
    
    const filterSensitiveLog: (obj: PublicIpv4PoolRange) => any;
}

export interface PublicIpv4Pool {
    
    PoolId?: string;
    
    Description?: string;
    
    PoolAddressRanges?: PublicIpv4PoolRange[];
    
    TotalAddressCount?: number;
    
    TotalAvailableAddressCount?: number;
    
    NetworkBorderGroup?: string;
    
    Tags?: Tag[];
}
export declare namespace PublicIpv4Pool {
    
    const filterSensitiveLog: (obj: PublicIpv4Pool) => any;
}
export interface DescribePublicIpv4PoolsResult {
    
    PublicIpv4Pools?: PublicIpv4Pool[];
    
    NextToken?: string;
}
export declare namespace DescribePublicIpv4PoolsResult {
    
    const filterSensitiveLog: (obj: DescribePublicIpv4PoolsResult) => any;
}
export interface DescribeRegionsRequest {
    
    Filters?: Filter[];
    
    RegionNames?: string[];
    
    DryRun?: boolean;
    
    AllRegions?: boolean;
}
export declare namespace DescribeRegionsRequest {
    
    const filterSensitiveLog: (obj: DescribeRegionsRequest) => any;
}

export interface Region {
    
    Endpoint?: string;
    
    RegionName?: string;
    
    OptInStatus?: string;
}
export declare namespace Region {
    
    const filterSensitiveLog: (obj: Region) => any;
}
export interface DescribeRegionsResult {
    
    Regions?: Region[];
}
export declare namespace DescribeRegionsResult {
    
    const filterSensitiveLog: (obj: DescribeRegionsResult) => any;
}
export interface DescribeReplaceRootVolumeTasksRequest {
    
    ReplaceRootVolumeTaskIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeReplaceRootVolumeTasksRequest {
    
    const filterSensitiveLog: (obj: DescribeReplaceRootVolumeTasksRequest) => any;
}
export interface DescribeReplaceRootVolumeTasksResult {
    
    ReplaceRootVolumeTasks?: ReplaceRootVolumeTask[];
    
    NextToken?: string;
}
export declare namespace DescribeReplaceRootVolumeTasksResult {
    
    const filterSensitiveLog: (obj: DescribeReplaceRootVolumeTasksResult) => any;
}
export declare enum OfferingClassType {
    CONVERTIBLE = "convertible",
    STANDARD = "standard"
}
export declare type OfferingTypeValues = "All Upfront" | "Heavy Utilization" | "Light Utilization" | "Medium Utilization" | "No Upfront" | "Partial Upfront";

export interface DescribeReservedInstancesRequest {
    
    Filters?: Filter[];
    
    OfferingClass?: OfferingClassType | string;
    
    ReservedInstancesIds?: string[];
    
    DryRun?: boolean;
    
    OfferingType?: OfferingTypeValues | string;
}
export declare namespace DescribeReservedInstancesRequest {
    
    const filterSensitiveLog: (obj: DescribeReservedInstancesRequest) => any;
}
export declare type RIProductDescription = "Linux/UNIX" | "Linux/UNIX (Amazon VPC)" | "Windows" | "Windows (Amazon VPC)";
export declare type RecurringChargeFrequency = "Hourly";

export interface RecurringCharge {
    
    Amount?: number;
    
    Frequency?: RecurringChargeFrequency | string;
}
export declare namespace RecurringCharge {
    
    const filterSensitiveLog: (obj: RecurringCharge) => any;
}
export declare enum Scope {
    AVAILABILITY_ZONE = "Availability Zone",
    REGIONAL = "Region"
}
export declare type ReservedInstanceState = "active" | "payment-failed" | "payment-pending" | "queued" | "queued-deleted" | "retired";

export interface ReservedInstances {
    
    AvailabilityZone?: string;
    
    Duration?: number;
    
    End?: Date;
    
    FixedPrice?: number;
    
    InstanceCount?: number;
    
    InstanceType?: _InstanceType | string;
    
    ProductDescription?: RIProductDescription | string;
    
    ReservedInstancesId?: string;
    
    Start?: Date;
    
    State?: ReservedInstanceState | string;
    
    UsagePrice?: number;
    
    CurrencyCode?: CurrencyCodeValues | string;
    
    InstanceTenancy?: Tenancy | string;
    
    OfferingClass?: OfferingClassType | string;
    
    OfferingType?: OfferingTypeValues | string;
    
    RecurringCharges?: RecurringCharge[];
    
    Scope?: Scope | string;
    
    Tags?: Tag[];
}
export declare namespace ReservedInstances {
    
    const filterSensitiveLog: (obj: ReservedInstances) => any;
}

export interface DescribeReservedInstancesResult {
    
    ReservedInstances?: ReservedInstances[];
}
export declare namespace DescribeReservedInstancesResult {
    
    const filterSensitiveLog: (obj: DescribeReservedInstancesResult) => any;
}

export interface DescribeReservedInstancesListingsRequest {
    
    Filters?: Filter[];
    
    ReservedInstancesId?: string;
    
    ReservedInstancesListingId?: string;
}
export declare namespace DescribeReservedInstancesListingsRequest {
    
    const filterSensitiveLog: (obj: DescribeReservedInstancesListingsRequest) => any;
}

export interface DescribeReservedInstancesListingsResult {
    
    ReservedInstancesListings?: ReservedInstancesListing[];
}
export declare namespace DescribeReservedInstancesListingsResult {
    
    const filterSensitiveLog: (obj: DescribeReservedInstancesListingsResult) => any;
}

export interface DescribeReservedInstancesModificationsRequest {
    
    Filters?: Filter[];
    
    ReservedInstancesModificationIds?: string[];
    
    NextToken?: string;
}
export declare namespace DescribeReservedInstancesModificationsRequest {
    
    const filterSensitiveLog: (obj: DescribeReservedInstancesModificationsRequest) => any;
}

export interface ReservedInstancesConfiguration {
    
    AvailabilityZone?: string;
    
    InstanceCount?: number;
    
    InstanceType?: _InstanceType | string;
    
    Platform?: string;
    
    Scope?: Scope | string;
}
export declare namespace ReservedInstancesConfiguration {
    
    const filterSensitiveLog: (obj: ReservedInstancesConfiguration) => any;
}

export interface ReservedInstancesModificationResult {
    
    ReservedInstancesId?: string;
    
    TargetConfiguration?: ReservedInstancesConfiguration;
}
export declare namespace ReservedInstancesModificationResult {
    
    const filterSensitiveLog: (obj: ReservedInstancesModificationResult) => any;
}

export interface ReservedInstancesId {
    
    ReservedInstancesId?: string;
}
export declare namespace ReservedInstancesId {
    
    const filterSensitiveLog: (obj: ReservedInstancesId) => any;
}

export interface ReservedInstancesModification {
    
    ClientToken?: string;
    
    CreateDate?: Date;
    
    EffectiveDate?: Date;
    
    ModificationResults?: ReservedInstancesModificationResult[];
    
    ReservedInstancesIds?: ReservedInstancesId[];
    
    ReservedInstancesModificationId?: string;
    
    Status?: string;
    
    StatusMessage?: string;
    
    UpdateDate?: Date;
}
export declare namespace ReservedInstancesModification {
    
    const filterSensitiveLog: (obj: ReservedInstancesModification) => any;
}

export interface DescribeReservedInstancesModificationsResult {
    
    NextToken?: string;
    
    ReservedInstancesModifications?: ReservedInstancesModification[];
}
export declare namespace DescribeReservedInstancesModificationsResult {
    
    const filterSensitiveLog: (obj: DescribeReservedInstancesModificationsResult) => any;
}

export interface DescribeReservedInstancesOfferingsRequest {
    
    AvailabilityZone?: string;
    
    Filters?: Filter[];
    
    IncludeMarketplace?: boolean;
    
    InstanceType?: _InstanceType | string;
    
    MaxDuration?: number;
    
    MaxInstanceCount?: number;
    
    MinDuration?: number;
    
    OfferingClass?: OfferingClassType | string;
    
    ProductDescription?: RIProductDescription | string;
    
    ReservedInstancesOfferingIds?: string[];
    
    DryRun?: boolean;
    
    InstanceTenancy?: Tenancy | string;
    
    MaxResults?: number;
    
    NextToken?: string;
    
    OfferingType?: OfferingTypeValues | string;
}
export declare namespace DescribeReservedInstancesOfferingsRequest {
    
    const filterSensitiveLog: (obj: DescribeReservedInstancesOfferingsRequest) => any;
}

export interface PricingDetail {
    
    Count?: number;
    
    Price?: number;
}
export declare namespace PricingDetail {
    
    const filterSensitiveLog: (obj: PricingDetail) => any;
}

export interface ReservedInstancesOffering {
    
    AvailabilityZone?: string;
    
    Duration?: number;
    
    FixedPrice?: number;
    
    InstanceType?: _InstanceType | string;
    
    ProductDescription?: RIProductDescription | string;
    
    ReservedInstancesOfferingId?: string;
    
    UsagePrice?: number;
    
    CurrencyCode?: CurrencyCodeValues | string;
    
    InstanceTenancy?: Tenancy | string;
    
    Marketplace?: boolean;
    
    OfferingClass?: OfferingClassType | string;
    
    OfferingType?: OfferingTypeValues | string;
    
    PricingDetails?: PricingDetail[];
    
    RecurringCharges?: RecurringCharge[];
    
    Scope?: Scope | string;
}
export declare namespace ReservedInstancesOffering {
    
    const filterSensitiveLog: (obj: ReservedInstancesOffering) => any;
}

export interface DescribeReservedInstancesOfferingsResult {
    
    ReservedInstancesOfferings?: ReservedInstancesOffering[];
    
    NextToken?: string;
}
export declare namespace DescribeReservedInstancesOfferingsResult {
    
    const filterSensitiveLog: (obj: DescribeReservedInstancesOfferingsResult) => any;
}
export interface DescribeRouteTablesRequest {
    
    Filters?: Filter[];
    
    DryRun?: boolean;
    
    RouteTableIds?: string[];
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeRouteTablesRequest {
    
    const filterSensitiveLog: (obj: DescribeRouteTablesRequest) => any;
}

export interface DescribeRouteTablesResult {
    
    RouteTables?: RouteTable[];
    
    NextToken?: string;
}
export declare namespace DescribeRouteTablesResult {
    
    const filterSensitiveLog: (obj: DescribeRouteTablesResult) => any;
}

export interface SlotDateTimeRangeRequest {
    
    EarliestTime: Date | undefined;
    
    LatestTime: Date | undefined;
}
export declare namespace SlotDateTimeRangeRequest {
    
    const filterSensitiveLog: (obj: SlotDateTimeRangeRequest) => any;
}

export interface ScheduledInstanceRecurrenceRequest {
    
    Frequency?: string;
    
    Interval?: number;
    
    OccurrenceDays?: number[];
    
    OccurrenceRelativeToEnd?: boolean;
    
    OccurrenceUnit?: string;
}
export declare namespace ScheduledInstanceRecurrenceRequest {
    
    const filterSensitiveLog: (obj: ScheduledInstanceRecurrenceRequest) => any;
}

export interface DescribeScheduledInstanceAvailabilityRequest {
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    FirstSlotStartTimeRange: SlotDateTimeRangeRequest | undefined;
    
    MaxResults?: number;
    
    MaxSlotDurationInHours?: number;
    
    MinSlotDurationInHours?: number;
    
    NextToken?: string;
    
    Recurrence: ScheduledInstanceRecurrenceRequest | undefined;
}
export declare namespace DescribeScheduledInstanceAvailabilityRequest {
    
    const filterSensitiveLog: (obj: DescribeScheduledInstanceAvailabilityRequest) => any;
}

export interface ScheduledInstanceRecurrence {
    
    Frequency?: string;
    
    Interval?: number;
    
    OccurrenceDaySet?: number[];
    
    OccurrenceRelativeToEnd?: boolean;
    
    OccurrenceUnit?: string;
}
export declare namespace ScheduledInstanceRecurrence {
    
    const filterSensitiveLog: (obj: ScheduledInstanceRecurrence) => any;
}

export interface ScheduledInstanceAvailability {
    
    AvailabilityZone?: string;
    
    AvailableInstanceCount?: number;
    
    FirstSlotStartTime?: Date;
    
    HourlyPrice?: string;
    
    InstanceType?: string;
    
    MaxTermDurationInDays?: number;
    
    MinTermDurationInDays?: number;
    
    NetworkPlatform?: string;
    
    Platform?: string;
    
    PurchaseToken?: string;
    
    Recurrence?: ScheduledInstanceRecurrence;
    
    SlotDurationInHours?: number;
    
    TotalScheduledInstanceHours?: number;
}
export declare namespace ScheduledInstanceAvailability {
    
    const filterSensitiveLog: (obj: ScheduledInstanceAvailability) => any;
}

export interface DescribeScheduledInstanceAvailabilityResult {
    
    NextToken?: string;
    
    ScheduledInstanceAvailabilitySet?: ScheduledInstanceAvailability[];
}
export declare namespace DescribeScheduledInstanceAvailabilityResult {
    
    const filterSensitiveLog: (obj: DescribeScheduledInstanceAvailabilityResult) => any;
}

export interface SlotStartTimeRangeRequest {
    
    EarliestTime?: Date;
    
    LatestTime?: Date;
}
export declare namespace SlotStartTimeRangeRequest {
    
    const filterSensitiveLog: (obj: SlotStartTimeRangeRequest) => any;
}

export interface DescribeScheduledInstancesRequest {
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    ScheduledInstanceIds?: string[];
    
    SlotStartTimeRange?: SlotStartTimeRangeRequest;
}
export declare namespace DescribeScheduledInstancesRequest {
    
    const filterSensitiveLog: (obj: DescribeScheduledInstancesRequest) => any;
}

export interface ScheduledInstance {
    
    AvailabilityZone?: string;
    
    CreateDate?: Date;
    
    HourlyPrice?: string;
    
    InstanceCount?: number;
    
    InstanceType?: string;
    
    NetworkPlatform?: string;
    
    NextSlotStartTime?: Date;
    
    Platform?: string;
    
    PreviousSlotEndTime?: Date;
    
    Recurrence?: ScheduledInstanceRecurrence;
    
    ScheduledInstanceId?: string;
    
    SlotDurationInHours?: number;
    
    TermEndDate?: Date;
    
    TermStartDate?: Date;
    
    TotalScheduledInstanceHours?: number;
}
export declare namespace ScheduledInstance {
    
    const filterSensitiveLog: (obj: ScheduledInstance) => any;
}

export interface DescribeScheduledInstancesResult {
    
    NextToken?: string;
    
    ScheduledInstanceSet?: ScheduledInstance[];
}
export declare namespace DescribeScheduledInstancesResult {
    
    const filterSensitiveLog: (obj: DescribeScheduledInstancesResult) => any;
}
export interface DescribeSecurityGroupReferencesRequest {
    
    DryRun?: boolean;
    
    GroupId: string[] | undefined;
}
export declare namespace DescribeSecurityGroupReferencesRequest {
    
    const filterSensitiveLog: (obj: DescribeSecurityGroupReferencesRequest) => any;
}

export interface SecurityGroupReference {
    
    GroupId?: string;
    
    ReferencingVpcId?: string;
    
    VpcPeeringConnectionId?: string;
}
export declare namespace SecurityGroupReference {
    
    const filterSensitiveLog: (obj: SecurityGroupReference) => any;
}
export interface DescribeSecurityGroupReferencesResult {
    
    SecurityGroupReferenceSet?: SecurityGroupReference[];
}
export declare namespace DescribeSecurityGroupReferencesResult {
    
    const filterSensitiveLog: (obj: DescribeSecurityGroupReferencesResult) => any;
}
export interface DescribeSecurityGroupRulesRequest {
    
    Filters?: Filter[];
    
    SecurityGroupRuleIds?: string[];
    
    DryRun?: boolean;
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeSecurityGroupRulesRequest {
    
    const filterSensitiveLog: (obj: DescribeSecurityGroupRulesRequest) => any;
}
export interface DescribeSecurityGroupRulesResult {
    
    SecurityGroupRules?: SecurityGroupRule[];
    
    NextToken?: string;
}
export declare namespace DescribeSecurityGroupRulesResult {
    
    const filterSensitiveLog: (obj: DescribeSecurityGroupRulesResult) => any;
}
export interface DescribeSecurityGroupsRequest {
    
    Filters?: Filter[];
    
    GroupIds?: string[];
    
    GroupNames?: string[];
    
    DryRun?: boolean;
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeSecurityGroupsRequest {
    
    const filterSensitiveLog: (obj: DescribeSecurityGroupsRequest) => any;
}

export interface SecurityGroup {
    
    Description?: string;
    
    GroupName?: string;
    
    IpPermissions?: IpPermission[];
    
    OwnerId?: string;
    
    GroupId?: string;
    
    IpPermissionsEgress?: IpPermission[];
    
    Tags?: Tag[];
    
    VpcId?: string;
}
export declare namespace SecurityGroup {
    
    const filterSensitiveLog: (obj: SecurityGroup) => any;
}
export interface DescribeSecurityGroupsResult {
    
    SecurityGroups?: SecurityGroup[];
    
    NextToken?: string;
}
export declare namespace DescribeSecurityGroupsResult {
    
    const filterSensitiveLog: (obj: DescribeSecurityGroupsResult) => any;
}
export declare type SnapshotAttributeName = "createVolumePermission" | "productCodes";
export interface DescribeSnapshotAttributeRequest {
    
    Attribute: SnapshotAttributeName | string | undefined;
    
    SnapshotId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace DescribeSnapshotAttributeRequest {
    
    const filterSensitiveLog: (obj: DescribeSnapshotAttributeRequest) => any;
}

export interface CreateVolumePermission {
    
    Group?: PermissionGroup | string;
    
    UserId?: string;
}
export declare namespace CreateVolumePermission {
    
    const filterSensitiveLog: (obj: CreateVolumePermission) => any;
}
export interface DescribeSnapshotAttributeResult {
    
    CreateVolumePermissions?: CreateVolumePermission[];
    
    ProductCodes?: ProductCode[];
    
    SnapshotId?: string;
}
export declare namespace DescribeSnapshotAttributeResult {
    
    const filterSensitiveLog: (obj: DescribeSnapshotAttributeResult) => any;
}
export interface DescribeSnapshotsRequest {
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    OwnerIds?: string[];
    
    RestorableByUserIds?: string[];
    
    SnapshotIds?: string[];
    
    DryRun?: boolean;
}
export declare namespace DescribeSnapshotsRequest {
    
    const filterSensitiveLog: (obj: DescribeSnapshotsRequest) => any;
}
export interface DescribeSnapshotsResult {
    
    Snapshots?: Snapshot[];
    
    NextToken?: string;
}
export declare namespace DescribeSnapshotsResult {
    
    const filterSensitiveLog: (obj: DescribeSnapshotsResult) => any;
}

export interface DescribeSpotDatafeedSubscriptionRequest {
    
    DryRun?: boolean;
}
export declare namespace DescribeSpotDatafeedSubscriptionRequest {
    
    const filterSensitiveLog: (obj: DescribeSpotDatafeedSubscriptionRequest) => any;
}

export interface DescribeSpotDatafeedSubscriptionResult {
    
    SpotDatafeedSubscription?: SpotDatafeedSubscription;
}
export declare namespace DescribeSpotDatafeedSubscriptionResult {
    
    const filterSensitiveLog: (obj: DescribeSpotDatafeedSubscriptionResult) => any;
}

export interface DescribeSpotFleetInstancesRequest {
    
    DryRun?: boolean;
    
    MaxResults?: number;
    
    NextToken?: string;
    
    SpotFleetRequestId: string | undefined;
}
export declare namespace DescribeSpotFleetInstancesRequest {
    
    const filterSensitiveLog: (obj: DescribeSpotFleetInstancesRequest) => any;
}

export interface DescribeSpotFleetInstancesResponse {
    
    ActiveInstances?: ActiveInstance[];
    
    NextToken?: string;
    
    SpotFleetRequestId?: string;
}
export declare namespace DescribeSpotFleetInstancesResponse {
    
    const filterSensitiveLog: (obj: DescribeSpotFleetInstancesResponse) => any;
}
export declare enum EventType {
    BATCH_CHANGE = "fleetRequestChange",
    ERROR = "error",
    INFORMATION = "information",
    INSTANCE_CHANGE = "instanceChange"
}

export interface DescribeSpotFleetRequestHistoryRequest {
    
    DryRun?: boolean;
    
    EventType?: EventType | string;
    
    MaxResults?: number;
    
    NextToken?: string;
    
    SpotFleetRequestId: string | undefined;
    
    StartTime: Date | undefined;
}
export declare namespace DescribeSpotFleetRequestHistoryRequest {
    
    const filterSensitiveLog: (obj: DescribeSpotFleetRequestHistoryRequest) => any;
}

export interface HistoryRecord {
    
    EventInformation?: EventInformation;
    
    EventType?: EventType | string;
    
    Timestamp?: Date;
}
export declare namespace HistoryRecord {
    
    const filterSensitiveLog: (obj: HistoryRecord) => any;
}

export interface DescribeSpotFleetRequestHistoryResponse {
    
    HistoryRecords?: HistoryRecord[];
    
    LastEvaluatedTime?: Date;
    
    NextToken?: string;
    
    SpotFleetRequestId?: string;
    
    StartTime?: Date;
}
export declare namespace DescribeSpotFleetRequestHistoryResponse {
    
    const filterSensitiveLog: (obj: DescribeSpotFleetRequestHistoryResponse) => any;
}

export interface DescribeSpotFleetRequestsRequest {
    
    DryRun?: boolean;
    
    MaxResults?: number;
    
    NextToken?: string;
    
    SpotFleetRequestIds?: string[];
}
export declare namespace DescribeSpotFleetRequestsRequest {
    
    const filterSensitiveLog: (obj: DescribeSpotFleetRequestsRequest) => any;
}
export declare enum ExcessCapacityTerminationPolicy {
    DEFAULT = "default",
    NO_TERMINATION = "noTermination"
}

export interface SpotFleetMonitoring {
    
    Enabled?: boolean;
}
export declare namespace SpotFleetMonitoring {
    
    const filterSensitiveLog: (obj: SpotFleetMonitoring) => any;
}

export interface InstanceNetworkInterfaceSpecification {
    
    AssociatePublicIpAddress?: boolean;
    
    DeleteOnTermination?: boolean;
    
    Description?: string;
    
    DeviceIndex?: number;
    
    Groups?: string[];
    
    Ipv6AddressCount?: number;
    
    Ipv6Addresses?: InstanceIpv6Address[];
    
    NetworkInterfaceId?: string;
    
    PrivateIpAddress?: string;
    
    PrivateIpAddresses?: PrivateIpAddressSpecification[];
    
    SecondaryPrivateIpAddressCount?: number;
    
    SubnetId?: string;
    
    AssociateCarrierIpAddress?: boolean;
    
    InterfaceType?: string;
    
    NetworkCardIndex?: number;
    
    Ipv4Prefixes?: Ipv4PrefixSpecificationRequest[];
    
    Ipv4PrefixCount?: number;
    
    Ipv6Prefixes?: Ipv6PrefixSpecificationRequest[];
    
    Ipv6PrefixCount?: number;
}
export declare namespace InstanceNetworkInterfaceSpecification {
    
    const filterSensitiveLog: (obj: InstanceNetworkInterfaceSpecification) => any;
}

export interface SpotPlacement {
    
    AvailabilityZone?: string;
    
    GroupName?: string;
    
    Tenancy?: Tenancy | string;
}
export declare namespace SpotPlacement {
    
    const filterSensitiveLog: (obj: SpotPlacement) => any;
}

export interface SpotFleetTagSpecification {
    
    ResourceType?: ResourceType | string;
    
    Tags?: Tag[];
}
export declare namespace SpotFleetTagSpecification {
    
    const filterSensitiveLog: (obj: SpotFleetTagSpecification) => any;
}

export interface SpotFleetLaunchSpecification {
    
    SecurityGroups?: GroupIdentifier[];
    
    AddressingType?: string;
    
    BlockDeviceMappings?: BlockDeviceMapping[];
    
    EbsOptimized?: boolean;
    
    IamInstanceProfile?: IamInstanceProfileSpecification;
    
    ImageId?: string;
    
    InstanceType?: _InstanceType | string;
    
    KernelId?: string;
    
    KeyName?: string;
    
    Monitoring?: SpotFleetMonitoring;
    
    NetworkInterfaces?: InstanceNetworkInterfaceSpecification[];
    
    Placement?: SpotPlacement;
    
    RamdiskId?: string;
    
    SpotPrice?: string;
    
    SubnetId?: string;
    
    UserData?: string;
    
    WeightedCapacity?: number;
    
    TagSpecifications?: SpotFleetTagSpecification[];
    
    InstanceRequirements?: InstanceRequirements;
}
export declare namespace SpotFleetLaunchSpecification {
    
    const filterSensitiveLog: (obj: SpotFleetLaunchSpecification) => any;
}

export interface LaunchTemplateOverrides {
    
    InstanceType?: _InstanceType | string;
    
    SpotPrice?: string;
    
    SubnetId?: string;
    
    AvailabilityZone?: string;
    
    WeightedCapacity?: number;
    
    Priority?: number;
    
    InstanceRequirements?: InstanceRequirements;
}
export declare namespace LaunchTemplateOverrides {
    
    const filterSensitiveLog: (obj: LaunchTemplateOverrides) => any;
}

export interface LaunchTemplateConfig {
    
    LaunchTemplateSpecification?: FleetLaunchTemplateSpecification;
    
    Overrides?: LaunchTemplateOverrides[];
}
export declare namespace LaunchTemplateConfig {
    
    const filterSensitiveLog: (obj: LaunchTemplateConfig) => any;
}

export interface ClassicLoadBalancer {
    
    Name?: string;
}
export declare namespace ClassicLoadBalancer {
    
    const filterSensitiveLog: (obj: ClassicLoadBalancer) => any;
}

export interface ClassicLoadBalancersConfig {
    
    ClassicLoadBalancers?: ClassicLoadBalancer[];
}
export declare namespace ClassicLoadBalancersConfig {
    
    const filterSensitiveLog: (obj: ClassicLoadBalancersConfig) => any;
}

export interface TargetGroup {
    
    Arn?: string;
}
export declare namespace TargetGroup {
    
    const filterSensitiveLog: (obj: TargetGroup) => any;
}

export interface TargetGroupsConfig {
    
    TargetGroups?: TargetGroup[];
}
export declare namespace TargetGroupsConfig {
    
    const filterSensitiveLog: (obj: TargetGroupsConfig) => any;
}

export interface LoadBalancersConfig {
    
    ClassicLoadBalancersConfig?: ClassicLoadBalancersConfig;
    
    TargetGroupsConfig?: TargetGroupsConfig;
}
export declare namespace LoadBalancersConfig {
    
    const filterSensitiveLog: (obj: LoadBalancersConfig) => any;
}
export declare enum OnDemandAllocationStrategy {
    LOWEST_PRICE = "lowestPrice",
    PRIORITIZED = "prioritized"
}
export declare enum ReplacementStrategy {
    LAUNCH = "launch",
    LAUNCH_BEFORE_TERMINATE = "launch-before-terminate"
}

export interface SpotCapacityRebalance {
    
    ReplacementStrategy?: ReplacementStrategy | string;
    
    TerminationDelay?: number;
}
export declare namespace SpotCapacityRebalance {
    
    const filterSensitiveLog: (obj: SpotCapacityRebalance) => any;
}

export interface SpotMaintenanceStrategies {
    
    CapacityRebalance?: SpotCapacityRebalance;
}
export declare namespace SpotMaintenanceStrategies {
    
    const filterSensitiveLog: (obj: SpotMaintenanceStrategies) => any;
}

export interface SpotFleetRequestConfigData {
    
    AllocationStrategy?: AllocationStrategy | string;
    
    OnDemandAllocationStrategy?: OnDemandAllocationStrategy | string;
    
    SpotMaintenanceStrategies?: SpotMaintenanceStrategies;
    
    ClientToken?: string;
    
    ExcessCapacityTerminationPolicy?: ExcessCapacityTerminationPolicy | string;
    
    FulfilledCapacity?: number;
    
    OnDemandFulfilledCapacity?: number;
    
    IamFleetRole: string | undefined;
    
    LaunchSpecifications?: SpotFleetLaunchSpecification[];
    
    LaunchTemplateConfigs?: LaunchTemplateConfig[];
    
    SpotPrice?: string;
    
    TargetCapacity: number | undefined;
    
    OnDemandTargetCapacity?: number;
    
    OnDemandMaxTotalPrice?: string;
    
    SpotMaxTotalPrice?: string;
    
    TerminateInstancesWithExpiration?: boolean;
    
    Type?: FleetType | string;
    
    ValidFrom?: Date;
    
    ValidUntil?: Date;
    
    ReplaceUnhealthyInstances?: boolean;
    
    InstanceInterruptionBehavior?: InstanceInterruptionBehavior | string;
    
    LoadBalancersConfig?: LoadBalancersConfig;
    
    InstancePoolsToUseCount?: number;
    
    Context?: string;
    
    TargetCapacityUnitType?: TargetCapacityUnitType | string;
    
    TagSpecifications?: TagSpecification[];
}
export declare namespace SpotFleetRequestConfigData {
    
    const filterSensitiveLog: (obj: SpotFleetRequestConfigData) => any;
}

export interface SpotFleetRequestConfig {
    
    ActivityStatus?: ActivityStatus | string;
    
    CreateTime?: Date;
    
    SpotFleetRequestConfig?: SpotFleetRequestConfigData;
    
    SpotFleetRequestId?: string;
    
    SpotFleetRequestState?: BatchState | string;
    
    Tags?: Tag[];
}
export declare namespace SpotFleetRequestConfig {
    
    const filterSensitiveLog: (obj: SpotFleetRequestConfig) => any;
}

export interface DescribeSpotFleetRequestsResponse {
    
    NextToken?: string;
    
    SpotFleetRequestConfigs?: SpotFleetRequestConfig[];
}
export declare namespace DescribeSpotFleetRequestsResponse {
    
    const filterSensitiveLog: (obj: DescribeSpotFleetRequestsResponse) => any;
}

export interface DescribeSpotInstanceRequestsRequest {
    
    Filters?: Filter[];
    
    DryRun?: boolean;
    
    SpotInstanceRequestIds?: string[];
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeSpotInstanceRequestsRequest {
    
    const filterSensitiveLog: (obj: DescribeSpotInstanceRequestsRequest) => any;
}

export interface RunInstancesMonitoringEnabled {
    
    Enabled: boolean | undefined;
}
export declare namespace RunInstancesMonitoringEnabled {
    
    const filterSensitiveLog: (obj: RunInstancesMonitoringEnabled) => any;
}

export interface LaunchSpecification {
    
    UserData?: string;
    
    SecurityGroups?: GroupIdentifier[];
    
    AddressingType?: string;
    
    BlockDeviceMappings?: BlockDeviceMapping[];
    
    EbsOptimized?: boolean;
    
    IamInstanceProfile?: IamInstanceProfileSpecification;
    
    ImageId?: string;
    
    InstanceType?: _InstanceType | string;
    
    KernelId?: string;
    
    KeyName?: string;
    
    NetworkInterfaces?: InstanceNetworkInterfaceSpecification[];
    
    Placement?: SpotPlacement;
    
    RamdiskId?: string;
    
    SubnetId?: string;
    
    Monitoring?: RunInstancesMonitoringEnabled;
}
export declare namespace LaunchSpecification {
    
    const filterSensitiveLog: (obj: LaunchSpecification) => any;
}
export declare type SpotInstanceState = "active" | "cancelled" | "closed" | "failed" | "open";

export interface SpotInstanceStatus {
    
    Code?: string;
    
    Message?: string;
    
    UpdateTime?: Date;
}
export declare namespace SpotInstanceStatus {
    
    const filterSensitiveLog: (obj: SpotInstanceStatus) => any;
}

export interface SpotInstanceRequest {
    
    ActualBlockHourlyPrice?: string;
    
    AvailabilityZoneGroup?: string;
    
    BlockDurationMinutes?: number;
    
    CreateTime?: Date;
    
    Fault?: SpotInstanceStateFault;
    
    InstanceId?: string;
    
    LaunchGroup?: string;
    
    LaunchSpecification?: LaunchSpecification;
    
    LaunchedAvailabilityZone?: string;
    
    ProductDescription?: RIProductDescription | string;
    
    SpotInstanceRequestId?: string;
    
    SpotPrice?: string;
    
    State?: SpotInstanceState | string;
    
    Status?: SpotInstanceStatus;
    
    Tags?: Tag[];
    
    Type?: SpotInstanceType | string;
    
    ValidFrom?: Date;
    
    ValidUntil?: Date;
    
    InstanceInterruptionBehavior?: InstanceInterruptionBehavior | string;
}
export declare namespace SpotInstanceRequest {
    
    const filterSensitiveLog: (obj: SpotInstanceRequest) => any;
}

export interface DescribeSpotInstanceRequestsResult {
    
    SpotInstanceRequests?: SpotInstanceRequest[];
    
    NextToken?: string;
}
export declare namespace DescribeSpotInstanceRequestsResult {
    
    const filterSensitiveLog: (obj: DescribeSpotInstanceRequestsResult) => any;
}

export interface DescribeSpotPriceHistoryRequest {
    
    Filters?: Filter[];
    
    AvailabilityZone?: string;
    
    DryRun?: boolean;
    
    EndTime?: Date;
    
    InstanceTypes?: (_InstanceType | string)[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    ProductDescriptions?: string[];
    
    StartTime?: Date;
}
export declare namespace DescribeSpotPriceHistoryRequest {
    
    const filterSensitiveLog: (obj: DescribeSpotPriceHistoryRequest) => any;
}

export interface SpotPrice {
    
    AvailabilityZone?: string;
    
    InstanceType?: _InstanceType | string;
    
    ProductDescription?: RIProductDescription | string;
    
    SpotPrice?: string;
    
    Timestamp?: Date;
}
export declare namespace SpotPrice {
    
    const filterSensitiveLog: (obj: SpotPrice) => any;
}

export interface DescribeSpotPriceHistoryResult {
    
    NextToken?: string;
    
    SpotPriceHistory?: SpotPrice[];
}
export declare namespace DescribeSpotPriceHistoryResult {
    
    const filterSensitiveLog: (obj: DescribeSpotPriceHistoryResult) => any;
}
export interface DescribeStaleSecurityGroupsRequest {
    
    DryRun?: boolean;
    
    MaxResults?: number;
    
    NextToken?: string;
    
    VpcId: string | undefined;
}
export declare namespace DescribeStaleSecurityGroupsRequest {
    
    const filterSensitiveLog: (obj: DescribeStaleSecurityGroupsRequest) => any;
}

export interface StaleIpPermission {
    
    FromPort?: number;
    
    IpProtocol?: string;
    
    IpRanges?: string[];
    
    PrefixListIds?: string[];
    
    ToPort?: number;
    
    UserIdGroupPairs?: UserIdGroupPair[];
}
export declare namespace StaleIpPermission {
    
    const filterSensitiveLog: (obj: StaleIpPermission) => any;
}

export interface StaleSecurityGroup {
    
    Description?: string;
    
    GroupId?: string;
    
    GroupName?: string;
    
    StaleIpPermissions?: StaleIpPermission[];
    
    StaleIpPermissionsEgress?: StaleIpPermission[];
    
    VpcId?: string;
}
export declare namespace StaleSecurityGroup {
    
    const filterSensitiveLog: (obj: StaleSecurityGroup) => any;
}
export interface DescribeStaleSecurityGroupsResult {
    
    NextToken?: string;
    
    StaleSecurityGroupSet?: StaleSecurityGroup[];
}
export declare namespace DescribeStaleSecurityGroupsResult {
    
    const filterSensitiveLog: (obj: DescribeStaleSecurityGroupsResult) => any;
}
export interface DescribeStoreImageTasksRequest {
    
    ImageIds?: string[];
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeStoreImageTasksRequest {
    
    const filterSensitiveLog: (obj: DescribeStoreImageTasksRequest) => any;
}

export interface StoreImageTaskResult {
    
    AmiId?: string;
    
    TaskStartTime?: Date;
    
    Bucket?: string;
    
    S3objectKey?: string;
    
    ProgressPercentage?: number;
    
    StoreTaskState?: string;
    
    StoreTaskFailureReason?: string;
}
export declare namespace StoreImageTaskResult {
    
    const filterSensitiveLog: (obj: StoreImageTaskResult) => any;
}
export interface DescribeStoreImageTasksResult {
    
    StoreImageTaskResults?: StoreImageTaskResult[];
    
    NextToken?: string;
}
export declare namespace DescribeStoreImageTasksResult {
    
    const filterSensitiveLog: (obj: DescribeStoreImageTasksResult) => any;
}
export interface DescribeSubnetsRequest {
    
    Filters?: Filter[];
    
    SubnetIds?: string[];
    
    DryRun?: boolean;
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeSubnetsRequest {
    
    const filterSensitiveLog: (obj: DescribeSubnetsRequest) => any;
}
