import { _InstanceType, AddPrefixListEntry, AddressAttribute, AddressAttributeName, Affinity, ApplianceModeSupportValue, AttributeValue, ByoipCidr, ClientVpnAuthorizationRuleStatus, CurrencyCodeValues, DnsSupportValue, IamInstanceProfileAssociation, IamInstanceProfileSpecification, InstanceEventWindow, IpPermission, Ipv6SupportValue, Placement, RouteTableAssociationState, TagSpecification, TransitGatewayAttachmentResourceType, TransitGatewayMulticastDomainAssociations, TransitGatewayPeeringAttachment, TransitGatewayVpcAttachment, UnsuccessfulItem } from "./models_0";
import { AutoAcceptSharedAttachmentsValue, BlockDeviceMapping, CreditSpecificationRequest, DefaultRouteTableAssociationValue, DefaultRouteTablePropagationValue, ElasticGpuSpecification, IcmpTypeCode, InstanceEventWindowTimeRangeRequest, InstanceInterruptionBehavior, InstanceIpv6Address, LaunchTemplate, LocalGatewayRoute, ManagedPrefixList, MarketType, PortRange, RuleAction, ShutdownBehavior, SpotInstanceType, TrafficDirection, TrafficMirrorFilter, TrafficMirrorFilterRule, TrafficMirrorNetworkService, TrafficMirrorPortRangeRequest, TrafficMirrorRuleAction, TrafficMirrorSession, TransitGateway, TransitGatewayPrefixListReference, TransitGatewayRoute, VolumeType, VpnEcmpSupportValue } from "./models_1";
import { ClientVpnConnectionStatus, Filter, IKEVersionsRequestListValue, InstanceTagNotificationAttribute, Phase1DHGroupNumbersRequestListValue, Phase1EncryptionAlgorithmsRequestListValue, Phase1IntegrityAlgorithmsRequestListValue, Phase2DHGroupNumbersRequestListValue, Phase2EncryptionAlgorithmsRequestListValue, Phase2IntegrityAlgorithmsRequestListValue, VpnConnection } from "./models_2";
import { ArchitectureValues, AttributeBooleanValue, BootModeValues, CreateVolumePermission, ExcessCapacityTerminationPolicy, HttpTokensState, InstanceAttributeName, InstanceMetadataEndpointState, InstanceMetadataOptionsResponse, InstanceMetadataProtocolState, InstanceNetworkInterfaceSpecification, InstanceState, InstanceStatusEvent, LaunchTemplateConfig, Monitoring, NetworkInsightsAnalysis, ReservedInstancesConfiguration, RunInstancesMonitoringEnabled, ScheduledInstance, SnapshotAttributeName, SpotFleetRequestConfigData, SpotInstanceRequest, SpotPlacement } from "./models_3";
import { CapacityReservationSpecification, OperationType, Purchase, VolumeModification } from "./models_4";

export interface SuccessfulInstanceCreditSpecificationItem {
    
    InstanceId?: string;
}
export declare namespace SuccessfulInstanceCreditSpecificationItem {
    
    const filterSensitiveLog: (obj: SuccessfulInstanceCreditSpecificationItem) => any;
}
export declare enum UnsuccessfulInstanceCreditSpecificationErrorCode {
    INCORRECT_INSTANCE_STATE = "IncorrectInstanceState",
    INSTANCE_CREDIT_SPECIFICATION_NOT_SUPPORTED = "InstanceCreditSpecification.NotSupported",
    INSTANCE_NOT_FOUND = "InvalidInstanceID.NotFound",
    INVALID_INSTANCE_ID = "InvalidInstanceID.Malformed"
}

export interface UnsuccessfulInstanceCreditSpecificationItemError {
    
    Code?: UnsuccessfulInstanceCreditSpecificationErrorCode | string;
    
    Message?: string;
}
export declare namespace UnsuccessfulInstanceCreditSpecificationItemError {
    
    const filterSensitiveLog: (obj: UnsuccessfulInstanceCreditSpecificationItemError) => any;
}

export interface UnsuccessfulInstanceCreditSpecificationItem {
    
    InstanceId?: string;
    
    Error?: UnsuccessfulInstanceCreditSpecificationItemError;
}
export declare namespace UnsuccessfulInstanceCreditSpecificationItem {
    
    const filterSensitiveLog: (obj: UnsuccessfulInstanceCreditSpecificationItem) => any;
}
export interface ModifyInstanceCreditSpecificationResult {
    
    SuccessfulInstanceCreditSpecifications?: SuccessfulInstanceCreditSpecificationItem[];
    
    UnsuccessfulInstanceCreditSpecifications?: UnsuccessfulInstanceCreditSpecificationItem[];
}
export declare namespace ModifyInstanceCreditSpecificationResult {
    
    const filterSensitiveLog: (obj: ModifyInstanceCreditSpecificationResult) => any;
}
export interface ModifyInstanceEventStartTimeRequest {
    
    DryRun?: boolean;
    
    InstanceId: string | undefined;
    
    InstanceEventId: string | undefined;
    
    NotBefore: Date | undefined;
}
export declare namespace ModifyInstanceEventStartTimeRequest {
    
    const filterSensitiveLog: (obj: ModifyInstanceEventStartTimeRequest) => any;
}
export interface ModifyInstanceEventStartTimeResult {
    
    Event?: InstanceStatusEvent;
}
export declare namespace ModifyInstanceEventStartTimeResult {
    
    const filterSensitiveLog: (obj: ModifyInstanceEventStartTimeResult) => any;
}
export interface ModifyInstanceEventWindowRequest {
    
    DryRun?: boolean;
    
    Name?: string;
    
    InstanceEventWindowId: string | undefined;
    
    TimeRanges?: InstanceEventWindowTimeRangeRequest[];
    
    CronExpression?: string;
}
export declare namespace ModifyInstanceEventWindowRequest {
    
    const filterSensitiveLog: (obj: ModifyInstanceEventWindowRequest) => any;
}
export interface ModifyInstanceEventWindowResult {
    
    InstanceEventWindow?: InstanceEventWindow;
}
export declare namespace ModifyInstanceEventWindowResult {
    
    const filterSensitiveLog: (obj: ModifyInstanceEventWindowResult) => any;
}
export interface ModifyInstanceMetadataOptionsRequest {
    
    InstanceId: string | undefined;
    
    HttpTokens?: HttpTokensState | string;
    
    HttpPutResponseHopLimit?: number;
    
    HttpEndpoint?: InstanceMetadataEndpointState | string;
    
    DryRun?: boolean;
    
    HttpProtocolIpv6?: InstanceMetadataProtocolState | string;
}
export declare namespace ModifyInstanceMetadataOptionsRequest {
    
    const filterSensitiveLog: (obj: ModifyInstanceMetadataOptionsRequest) => any;
}
export interface ModifyInstanceMetadataOptionsResult {
    
    InstanceId?: string;
    
    InstanceMetadataOptions?: InstanceMetadataOptionsResponse;
}
export declare namespace ModifyInstanceMetadataOptionsResult {
    
    const filterSensitiveLog: (obj: ModifyInstanceMetadataOptionsResult) => any;
}
export declare type HostTenancy = "dedicated" | "host";
export interface ModifyInstancePlacementRequest {
    
    Affinity?: Affinity | string;
    
    GroupName?: string;
    
    HostId?: string;
    
    InstanceId: string | undefined;
    
    Tenancy?: HostTenancy | string;
    
    PartitionNumber?: number;
    
    HostResourceGroupArn?: string;
}
export declare namespace ModifyInstancePlacementRequest {
    
    const filterSensitiveLog: (obj: ModifyInstancePlacementRequest) => any;
}
export interface ModifyInstancePlacementResult {
    
    Return?: boolean;
}
export declare namespace ModifyInstancePlacementResult {
    
    const filterSensitiveLog: (obj: ModifyInstancePlacementResult) => any;
}
export interface ModifyLaunchTemplateRequest {
    
    DryRun?: boolean;
    
    ClientToken?: string;
    
    LaunchTemplateId?: string;
    
    LaunchTemplateName?: string;
    
    DefaultVersion?: string;
}
export declare namespace ModifyLaunchTemplateRequest {
    
    const filterSensitiveLog: (obj: ModifyLaunchTemplateRequest) => any;
}
export interface ModifyLaunchTemplateResult {
    
    LaunchTemplate?: LaunchTemplate;
}
export declare namespace ModifyLaunchTemplateResult {
    
    const filterSensitiveLog: (obj: ModifyLaunchTemplateResult) => any;
}

export interface RemovePrefixListEntry {
    
    Cidr: string | undefined;
}
export declare namespace RemovePrefixListEntry {
    
    const filterSensitiveLog: (obj: RemovePrefixListEntry) => any;
}
export interface ModifyManagedPrefixListRequest {
    
    DryRun?: boolean;
    
    PrefixListId: string | undefined;
    
    CurrentVersion?: number;
    
    PrefixListName?: string;
    
    AddEntries?: AddPrefixListEntry[];
    
    RemoveEntries?: RemovePrefixListEntry[];
    
    MaxEntries?: number;
}
export declare namespace ModifyManagedPrefixListRequest {
    
    const filterSensitiveLog: (obj: ModifyManagedPrefixListRequest) => any;
}
export interface ModifyManagedPrefixListResult {
    
    PrefixList?: ManagedPrefixList;
}
export declare namespace ModifyManagedPrefixListResult {
    
    const filterSensitiveLog: (obj: ModifyManagedPrefixListResult) => any;
}

export interface NetworkInterfaceAttachmentChanges {
    
    AttachmentId?: string;
    
    DeleteOnTermination?: boolean;
}
export declare namespace NetworkInterfaceAttachmentChanges {
    
    const filterSensitiveLog: (obj: NetworkInterfaceAttachmentChanges) => any;
}

export interface ModifyNetworkInterfaceAttributeRequest {
    
    Attachment?: NetworkInterfaceAttachmentChanges;
    
    Description?: AttributeValue;
    
    DryRun?: boolean;
    
    Groups?: string[];
    
    NetworkInterfaceId: string | undefined;
    
    SourceDestCheck?: AttributeBooleanValue;
}
export declare namespace ModifyNetworkInterfaceAttributeRequest {
    
    const filterSensitiveLog: (obj: ModifyNetworkInterfaceAttributeRequest) => any;
}

export interface ModifyReservedInstancesRequest {
    
    ReservedInstancesIds: string[] | undefined;
    
    ClientToken?: string;
    
    TargetConfigurations: ReservedInstancesConfiguration[] | undefined;
}
export declare namespace ModifyReservedInstancesRequest {
    
    const filterSensitiveLog: (obj: ModifyReservedInstancesRequest) => any;
}

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

export interface SecurityGroupRuleRequest {
    
    IpProtocol?: string;
    
    FromPort?: number;
    
    ToPort?: number;
    
    CidrIpv4?: string;
    
    CidrIpv6?: string;
    
    PrefixListId?: string;
    
    ReferencedGroupId?: string;
    
    Description?: string;
}
export declare namespace SecurityGroupRuleRequest {
    
    const filterSensitiveLog: (obj: SecurityGroupRuleRequest) => any;
}

export interface SecurityGroupRuleUpdate {
    
    SecurityGroupRuleId?: string;
    
    SecurityGroupRule?: SecurityGroupRuleRequest;
}
export declare namespace SecurityGroupRuleUpdate {
    
    const filterSensitiveLog: (obj: SecurityGroupRuleUpdate) => any;
}
export interface ModifySecurityGroupRulesRequest {
    
    GroupId: string | undefined;
    
    SecurityGroupRules: SecurityGroupRuleUpdate[] | undefined;
    
    DryRun?: boolean;
}
export declare namespace ModifySecurityGroupRulesRequest {
    
    const filterSensitiveLog: (obj: ModifySecurityGroupRulesRequest) => any;
}
export interface ModifySecurityGroupRulesResult {
    
    Return?: boolean;
}
export declare namespace ModifySecurityGroupRulesResult {
    
    const filterSensitiveLog: (obj: ModifySecurityGroupRulesResult) => any;
}

export interface CreateVolumePermissionModifications {
    
    Add?: CreateVolumePermission[];
    
    Remove?: CreateVolumePermission[];
}
export declare namespace CreateVolumePermissionModifications {
    
    const filterSensitiveLog: (obj: CreateVolumePermissionModifications) => any;
}
export interface ModifySnapshotAttributeRequest {
    
    Attribute?: SnapshotAttributeName | string;
    
    CreateVolumePermission?: CreateVolumePermissionModifications;
    
    GroupNames?: string[];
    
    OperationType?: OperationType | string;
    
    SnapshotId: string | undefined;
    
    UserIds?: string[];
    
    DryRun?: boolean;
}
export declare namespace ModifySnapshotAttributeRequest {
    
    const filterSensitiveLog: (obj: ModifySnapshotAttributeRequest) => any;
}

export interface ModifySpotFleetRequestRequest {
    
    ExcessCapacityTerminationPolicy?: ExcessCapacityTerminationPolicy | string;
    
    LaunchTemplateConfigs?: LaunchTemplateConfig[];
    
    SpotFleetRequestId: string | undefined;
    
    TargetCapacity?: number;
    
    OnDemandTargetCapacity?: number;
    
    Context?: string;
}
export declare namespace ModifySpotFleetRequestRequest {
    
    const filterSensitiveLog: (obj: ModifySpotFleetRequestRequest) => any;
}

export interface ModifySpotFleetRequestResponse {
    
    Return?: boolean;
}
export declare namespace ModifySpotFleetRequestResponse {
    
    const filterSensitiveLog: (obj: ModifySpotFleetRequestResponse) => any;
}
export interface ModifySubnetAttributeRequest {
    
    AssignIpv6AddressOnCreation?: AttributeBooleanValue;
    
    MapPublicIpOnLaunch?: AttributeBooleanValue;
    
    SubnetId: string | undefined;
    
    MapCustomerOwnedIpOnLaunch?: AttributeBooleanValue;
    
    CustomerOwnedIpv4Pool?: string;
}
export declare namespace ModifySubnetAttributeRequest {
    
    const filterSensitiveLog: (obj: ModifySubnetAttributeRequest) => any;
}
export interface ModifyTrafficMirrorFilterNetworkServicesRequest {
    
    TrafficMirrorFilterId: string | undefined;
    
    AddNetworkServices?: (TrafficMirrorNetworkService | string)[];
    
    RemoveNetworkServices?: (TrafficMirrorNetworkService | string)[];
    
    DryRun?: boolean;
}
export declare namespace ModifyTrafficMirrorFilterNetworkServicesRequest {
    
    const filterSensitiveLog: (obj: ModifyTrafficMirrorFilterNetworkServicesRequest) => any;
}
export interface ModifyTrafficMirrorFilterNetworkServicesResult {
    
    TrafficMirrorFilter?: TrafficMirrorFilter;
}
export declare namespace ModifyTrafficMirrorFilterNetworkServicesResult {
    
    const filterSensitiveLog: (obj: ModifyTrafficMirrorFilterNetworkServicesResult) => any;
}
export declare type TrafficMirrorFilterRuleField = "description" | "destination-port-range" | "protocol" | "source-port-range";
export interface ModifyTrafficMirrorFilterRuleRequest {
    
    TrafficMirrorFilterRuleId: string | undefined;
    
    TrafficDirection?: TrafficDirection | string;
    
    RuleNumber?: number;
    
    RuleAction?: TrafficMirrorRuleAction | string;
    
    DestinationPortRange?: TrafficMirrorPortRangeRequest;
    
    SourcePortRange?: TrafficMirrorPortRangeRequest;
    
    Protocol?: number;
    
    DestinationCidrBlock?: string;
    
    SourceCidrBlock?: string;
    
    Description?: string;
    
    RemoveFields?: (TrafficMirrorFilterRuleField | string)[];
    
    DryRun?: boolean;
}
export declare namespace ModifyTrafficMirrorFilterRuleRequest {
    
    const filterSensitiveLog: (obj: ModifyTrafficMirrorFilterRuleRequest) => any;
}
export interface ModifyTrafficMirrorFilterRuleResult {
    
    TrafficMirrorFilterRule?: TrafficMirrorFilterRule;
}
export declare namespace ModifyTrafficMirrorFilterRuleResult {
    
    const filterSensitiveLog: (obj: ModifyTrafficMirrorFilterRuleResult) => any;
}
export declare type TrafficMirrorSessionField = "description" | "packet-length" | "virtual-network-id";
export interface ModifyTrafficMirrorSessionRequest {
    
    TrafficMirrorSessionId: string | undefined;
    
    TrafficMirrorTargetId?: string;
    
    TrafficMirrorFilterId?: string;
    
    PacketLength?: number;
    
    SessionNumber?: number;
    
    VirtualNetworkId?: number;
    
    Description?: string;
    
    RemoveFields?: (TrafficMirrorSessionField | string)[];
    
    DryRun?: boolean;
}
export declare namespace ModifyTrafficMirrorSessionRequest {
    
    const filterSensitiveLog: (obj: ModifyTrafficMirrorSessionRequest) => any;
}
export interface ModifyTrafficMirrorSessionResult {
    
    TrafficMirrorSession?: TrafficMirrorSession;
}
export declare namespace ModifyTrafficMirrorSessionResult {
    
    const filterSensitiveLog: (obj: ModifyTrafficMirrorSessionResult) => any;
}

export interface ModifyTransitGatewayOptions {
    
    AddTransitGatewayCidrBlocks?: string[];
    
    RemoveTransitGatewayCidrBlocks?: string[];
    
    VpnEcmpSupport?: VpnEcmpSupportValue | string;
    
    DnsSupport?: DnsSupportValue | string;
    
    AutoAcceptSharedAttachments?: AutoAcceptSharedAttachmentsValue | string;
    
    DefaultRouteTableAssociation?: DefaultRouteTableAssociationValue | string;
    
    AssociationDefaultRouteTableId?: string;
    
    DefaultRouteTablePropagation?: DefaultRouteTablePropagationValue | string;
    
    PropagationDefaultRouteTableId?: string;
}
export declare namespace ModifyTransitGatewayOptions {
    
    const filterSensitiveLog: (obj: ModifyTransitGatewayOptions) => any;
}
export interface ModifyTransitGatewayRequest {
    
    TransitGatewayId: string | undefined;
    
    Description?: string;
    
    Options?: ModifyTransitGatewayOptions;
    
    DryRun?: boolean;
}
export declare namespace ModifyTransitGatewayRequest {
    
    const filterSensitiveLog: (obj: ModifyTransitGatewayRequest) => any;
}
export interface ModifyTransitGatewayResult {
    
    TransitGateway?: TransitGateway;
}
export declare namespace ModifyTransitGatewayResult {
    
    const filterSensitiveLog: (obj: ModifyTransitGatewayResult) => any;
}
export interface ModifyTransitGatewayPrefixListReferenceRequest {
    
    TransitGatewayRouteTableId: string | undefined;
    
    PrefixListId: string | undefined;
    
    TransitGatewayAttachmentId?: string;
    
    Blackhole?: boolean;
    
    DryRun?: boolean;
}
export declare namespace ModifyTransitGatewayPrefixListReferenceRequest {
    
    const filterSensitiveLog: (obj: ModifyTransitGatewayPrefixListReferenceRequest) => any;
}
export interface ModifyTransitGatewayPrefixListReferenceResult {
    
    TransitGatewayPrefixListReference?: TransitGatewayPrefixListReference;
}
export declare namespace ModifyTransitGatewayPrefixListReferenceResult {
    
    const filterSensitiveLog: (obj: ModifyTransitGatewayPrefixListReferenceResult) => any;
}

export interface ModifyTransitGatewayVpcAttachmentRequestOptions {
    
    DnsSupport?: DnsSupportValue | string;
    
    Ipv6Support?: Ipv6SupportValue | string;
    
    ApplianceModeSupport?: ApplianceModeSupportValue | string;
}
export declare namespace ModifyTransitGatewayVpcAttachmentRequestOptions {
    
    const filterSensitiveLog: (obj: ModifyTransitGatewayVpcAttachmentRequestOptions) => any;
}
export interface ModifyTransitGatewayVpcAttachmentRequest {
    
    TransitGatewayAttachmentId: string | undefined;
    
    AddSubnetIds?: string[];
    
    RemoveSubnetIds?: string[];
    
    Options?: ModifyTransitGatewayVpcAttachmentRequestOptions;
    
    DryRun?: boolean;
}
export declare namespace ModifyTransitGatewayVpcAttachmentRequest {
    
    const filterSensitiveLog: (obj: ModifyTransitGatewayVpcAttachmentRequest) => any;
}
export interface ModifyTransitGatewayVpcAttachmentResult {
    
    TransitGatewayVpcAttachment?: TransitGatewayVpcAttachment;
}
export declare namespace ModifyTransitGatewayVpcAttachmentResult {
    
    const filterSensitiveLog: (obj: ModifyTransitGatewayVpcAttachmentResult) => any;
}
export interface ModifyVolumeRequest {
    
    DryRun?: boolean;
    
    VolumeId: string | undefined;
    
    Size?: number;
    
    VolumeType?: VolumeType | string;
    
    Iops?: number;
    
    Throughput?: number;
    
    MultiAttachEnabled?: boolean;
}
export declare namespace ModifyVolumeRequest {
    
    const filterSensitiveLog: (obj: ModifyVolumeRequest) => any;
}
export interface ModifyVolumeResult {
    
    VolumeModification?: VolumeModification;
}
export declare namespace ModifyVolumeResult {
    
    const filterSensitiveLog: (obj: ModifyVolumeResult) => any;
}
export interface ModifyVolumeAttributeRequest {
    
    AutoEnableIO?: AttributeBooleanValue;
    
    VolumeId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace ModifyVolumeAttributeRequest {
    
    const filterSensitiveLog: (obj: ModifyVolumeAttributeRequest) => any;
}
export interface ModifyVpcAttributeRequest {
    
    EnableDnsHostnames?: AttributeBooleanValue;
    
    EnableDnsSupport?: AttributeBooleanValue;
    
    VpcId: string | undefined;
}
export declare namespace ModifyVpcAttributeRequest {
    
    const filterSensitiveLog: (obj: ModifyVpcAttributeRequest) => any;
}

export interface ModifyVpcEndpointRequest {
    
    DryRun?: boolean;
    
    VpcEndpointId: string | undefined;
    
    ResetPolicy?: boolean;
    
    PolicyDocument?: string;
    
    AddRouteTableIds?: string[];
    
    RemoveRouteTableIds?: string[];
    
    AddSubnetIds?: string[];
    
    RemoveSubnetIds?: string[];
    
    AddSecurityGroupIds?: string[];
    
    RemoveSecurityGroupIds?: string[];
    
    PrivateDnsEnabled?: boolean;
}
export declare namespace ModifyVpcEndpointRequest {
    
    const filterSensitiveLog: (obj: ModifyVpcEndpointRequest) => any;
}
export interface ModifyVpcEndpointResult {
    
    Return?: boolean;
}
export declare namespace ModifyVpcEndpointResult {
    
    const filterSensitiveLog: (obj: ModifyVpcEndpointResult) => any;
}
export interface ModifyVpcEndpointConnectionNotificationRequest {
    
    DryRun?: boolean;
    
    ConnectionNotificationId: string | undefined;
    
    ConnectionNotificationArn?: string;
    
    ConnectionEvents?: string[];
}
export declare namespace ModifyVpcEndpointConnectionNotificationRequest {
    
    const filterSensitiveLog: (obj: ModifyVpcEndpointConnectionNotificationRequest) => any;
}
export interface ModifyVpcEndpointConnectionNotificationResult {
    
    ReturnValue?: boolean;
}
export declare namespace ModifyVpcEndpointConnectionNotificationResult {
    
    const filterSensitiveLog: (obj: ModifyVpcEndpointConnectionNotificationResult) => any;
}
export interface ModifyVpcEndpointServiceConfigurationRequest {
    
    DryRun?: boolean;
    
    ServiceId: string | undefined;
    
    PrivateDnsName?: string;
    
    RemovePrivateDnsName?: boolean;
    
    AcceptanceRequired?: boolean;
    
    AddNetworkLoadBalancerArns?: string[];
    
    RemoveNetworkLoadBalancerArns?: string[];
    
    AddGatewayLoadBalancerArns?: string[];
    
    RemoveGatewayLoadBalancerArns?: string[];
}
export declare namespace ModifyVpcEndpointServiceConfigurationRequest {
    
    const filterSensitiveLog: (obj: ModifyVpcEndpointServiceConfigurationRequest) => any;
}
export interface ModifyVpcEndpointServiceConfigurationResult {
    
    Return?: boolean;
}
export declare namespace ModifyVpcEndpointServiceConfigurationResult {
    
    const filterSensitiveLog: (obj: ModifyVpcEndpointServiceConfigurationResult) => any;
}
export interface ModifyVpcEndpointServicePermissionsRequest {
    
    DryRun?: boolean;
    
    ServiceId: string | undefined;
    
    AddAllowedPrincipals?: string[];
    
    RemoveAllowedPrincipals?: string[];
}
export declare namespace ModifyVpcEndpointServicePermissionsRequest {
    
    const filterSensitiveLog: (obj: ModifyVpcEndpointServicePermissionsRequest) => any;
}
export interface ModifyVpcEndpointServicePermissionsResult {
    
    ReturnValue?: boolean;
}
export declare namespace ModifyVpcEndpointServicePermissionsResult {
    
    const filterSensitiveLog: (obj: ModifyVpcEndpointServicePermissionsResult) => any;
}

export interface PeeringConnectionOptionsRequest {
    
    AllowDnsResolutionFromRemoteVpc?: boolean;
    
    AllowEgressFromLocalClassicLinkToRemoteVpc?: boolean;
    
    AllowEgressFromLocalVpcToRemoteClassicLink?: boolean;
}
export declare namespace PeeringConnectionOptionsRequest {
    
    const filterSensitiveLog: (obj: PeeringConnectionOptionsRequest) => any;
}
export interface ModifyVpcPeeringConnectionOptionsRequest {
    
    AccepterPeeringConnectionOptions?: PeeringConnectionOptionsRequest;
    
    DryRun?: boolean;
    
    RequesterPeeringConnectionOptions?: PeeringConnectionOptionsRequest;
    
    VpcPeeringConnectionId: string | undefined;
}
export declare namespace ModifyVpcPeeringConnectionOptionsRequest {
    
    const filterSensitiveLog: (obj: ModifyVpcPeeringConnectionOptionsRequest) => any;
}

export interface PeeringConnectionOptions {
    
    AllowDnsResolutionFromRemoteVpc?: boolean;
    
    AllowEgressFromLocalClassicLinkToRemoteVpc?: boolean;
    
    AllowEgressFromLocalVpcToRemoteClassicLink?: boolean;
}
export declare namespace PeeringConnectionOptions {
    
    const filterSensitiveLog: (obj: PeeringConnectionOptions) => any;
}
export interface ModifyVpcPeeringConnectionOptionsResult {
    
    AccepterPeeringConnectionOptions?: PeeringConnectionOptions;
    
    RequesterPeeringConnectionOptions?: PeeringConnectionOptions;
}
export declare namespace ModifyVpcPeeringConnectionOptionsResult {
    
    const filterSensitiveLog: (obj: ModifyVpcPeeringConnectionOptionsResult) => any;
}
export declare type VpcTenancy = "default";
export interface ModifyVpcTenancyRequest {
    
    VpcId: string | undefined;
    
    InstanceTenancy: VpcTenancy | string | undefined;
    
    DryRun?: boolean;
}
export declare namespace ModifyVpcTenancyRequest {
    
    const filterSensitiveLog: (obj: ModifyVpcTenancyRequest) => any;
}
export interface ModifyVpcTenancyResult {
    
    ReturnValue?: boolean;
}
export declare namespace ModifyVpcTenancyResult {
    
    const filterSensitiveLog: (obj: ModifyVpcTenancyResult) => any;
}
export interface ModifyVpnConnectionRequest {
    
    VpnConnectionId: string | undefined;
    
    TransitGatewayId?: string;
    
    CustomerGatewayId?: string;
    
    VpnGatewayId?: string;
    
    DryRun?: boolean;
}
export declare namespace ModifyVpnConnectionRequest {
    
    const filterSensitiveLog: (obj: ModifyVpnConnectionRequest) => any;
}
export interface ModifyVpnConnectionResult {
    
    VpnConnection?: VpnConnection;
}
export declare namespace ModifyVpnConnectionResult {
    
    const filterSensitiveLog: (obj: ModifyVpnConnectionResult) => any;
}
export interface ModifyVpnConnectionOptionsRequest {
    
    VpnConnectionId: string | undefined;
    
    LocalIpv4NetworkCidr?: string;
    
    RemoteIpv4NetworkCidr?: string;
    
    LocalIpv6NetworkCidr?: string;
    
    RemoteIpv6NetworkCidr?: string;
    
    DryRun?: boolean;
}
export declare namespace ModifyVpnConnectionOptionsRequest {
    
    const filterSensitiveLog: (obj: ModifyVpnConnectionOptionsRequest) => any;
}
export interface ModifyVpnConnectionOptionsResult {
    
    VpnConnection?: VpnConnection;
}
export declare namespace ModifyVpnConnectionOptionsResult {
    
    const filterSensitiveLog: (obj: ModifyVpnConnectionOptionsResult) => any;
}
export interface ModifyVpnTunnelCertificateRequest {
    
    VpnConnectionId: string | undefined;
    
    VpnTunnelOutsideIpAddress: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace ModifyVpnTunnelCertificateRequest {
    
    const filterSensitiveLog: (obj: ModifyVpnTunnelCertificateRequest) => any;
}
export interface ModifyVpnTunnelCertificateResult {
    
    VpnConnection?: VpnConnection;
}
export declare namespace ModifyVpnTunnelCertificateResult {
    
    const filterSensitiveLog: (obj: ModifyVpnTunnelCertificateResult) => any;
}

export interface ModifyVpnTunnelOptionsSpecification {
    
    TunnelInsideCidr?: string;
    
    TunnelInsideIpv6Cidr?: string;
    
    PreSharedKey?: string;
    
    Phase1LifetimeSeconds?: number;
    
    Phase2LifetimeSeconds?: number;
    
    RekeyMarginTimeSeconds?: number;
    
    RekeyFuzzPercentage?: number;
    
    ReplayWindowSize?: number;
    
    DPDTimeoutSeconds?: number;
    
    DPDTimeoutAction?: string;
    
    Phase1EncryptionAlgorithms?: Phase1EncryptionAlgorithmsRequestListValue[];
    
    Phase2EncryptionAlgorithms?: Phase2EncryptionAlgorithmsRequestListValue[];
    
    Phase1IntegrityAlgorithms?: Phase1IntegrityAlgorithmsRequestListValue[];
    
    Phase2IntegrityAlgorithms?: Phase2IntegrityAlgorithmsRequestListValue[];
    
    Phase1DHGroupNumbers?: Phase1DHGroupNumbersRequestListValue[];
    
    Phase2DHGroupNumbers?: Phase2DHGroupNumbersRequestListValue[];
    
    IKEVersions?: IKEVersionsRequestListValue[];
    
    StartupAction?: string;
}
export declare namespace ModifyVpnTunnelOptionsSpecification {
    
    const filterSensitiveLog: (obj: ModifyVpnTunnelOptionsSpecification) => any;
}
export interface ModifyVpnTunnelOptionsRequest {
    
    VpnConnectionId: string | undefined;
    
    VpnTunnelOutsideIpAddress: string | undefined;
    
    TunnelOptions: ModifyVpnTunnelOptionsSpecification | undefined;
    
    DryRun?: boolean;
}
export declare namespace ModifyVpnTunnelOptionsRequest {
    
    const filterSensitiveLog: (obj: ModifyVpnTunnelOptionsRequest) => any;
}
export interface ModifyVpnTunnelOptionsResult {
    
    VpnConnection?: VpnConnection;
}
export declare namespace ModifyVpnTunnelOptionsResult {
    
    const filterSensitiveLog: (obj: ModifyVpnTunnelOptionsResult) => any;
}
export interface MonitorInstancesRequest {
    
    InstanceIds: string[] | undefined;
    
    DryRun?: boolean;
}
export declare namespace MonitorInstancesRequest {
    
    const filterSensitiveLog: (obj: MonitorInstancesRequest) => any;
}

export interface InstanceMonitoring {
    
    InstanceId?: string;
    
    Monitoring?: Monitoring;
}
export declare namespace InstanceMonitoring {
    
    const filterSensitiveLog: (obj: InstanceMonitoring) => any;
}
export interface MonitorInstancesResult {
    
    InstanceMonitorings?: InstanceMonitoring[];
}
export declare namespace MonitorInstancesResult {
    
    const filterSensitiveLog: (obj: MonitorInstancesResult) => any;
}
export interface MoveAddressToVpcRequest {
    
    DryRun?: boolean;
    
    PublicIp: string | undefined;
}
export declare namespace MoveAddressToVpcRequest {
    
    const filterSensitiveLog: (obj: MoveAddressToVpcRequest) => any;
}
export declare enum Status {
    inClassic = "InClassic",
    inVpc = "InVpc",
    moveInProgress = "MoveInProgress"
}
export interface MoveAddressToVpcResult {
    
    AllocationId?: string;
    
    Status?: Status | string;
}
export declare namespace MoveAddressToVpcResult {
    
    const filterSensitiveLog: (obj: MoveAddressToVpcResult) => any;
}

export interface CidrAuthorizationContext {
    
    Message: string | undefined;
    
    Signature: string | undefined;
}
export declare namespace CidrAuthorizationContext {
    
    const filterSensitiveLog: (obj: CidrAuthorizationContext) => any;
}
export interface ProvisionByoipCidrRequest {
    
    Cidr: string | undefined;
    
    CidrAuthorizationContext?: CidrAuthorizationContext;
    
    PubliclyAdvertisable?: boolean;
    
    Description?: string;
    
    DryRun?: boolean;
    
    PoolTagSpecifications?: TagSpecification[];
    
    MultiRegion?: boolean;
}
export declare namespace ProvisionByoipCidrRequest {
    
    const filterSensitiveLog: (obj: ProvisionByoipCidrRequest) => any;
}
export interface ProvisionByoipCidrResult {
    
    ByoipCidr?: ByoipCidr;
}
export declare namespace ProvisionByoipCidrResult {
    
    const filterSensitiveLog: (obj: ProvisionByoipCidrResult) => any;
}
export interface PurchaseHostReservationRequest {
    
    ClientToken?: string;
    
    CurrencyCode?: CurrencyCodeValues | string;
    
    HostIdSet: string[] | undefined;
    
    LimitPrice?: string;
    
    OfferingId: string | undefined;
    
    TagSpecifications?: TagSpecification[];
}
export declare namespace PurchaseHostReservationRequest {
    
    const filterSensitiveLog: (obj: PurchaseHostReservationRequest) => any;
}
export interface PurchaseHostReservationResult {
    
    ClientToken?: string;
    
    CurrencyCode?: CurrencyCodeValues | string;
    
    Purchase?: Purchase[];
    
    TotalHourlyPrice?: string;
    
    TotalUpfrontPrice?: string;
}
export declare namespace PurchaseHostReservationResult {
    
    const filterSensitiveLog: (obj: PurchaseHostReservationResult) => any;
}

export interface ReservedInstanceLimitPrice {
    
    Amount?: number;
    
    CurrencyCode?: CurrencyCodeValues | string;
}
export declare namespace ReservedInstanceLimitPrice {
    
    const filterSensitiveLog: (obj: ReservedInstanceLimitPrice) => any;
}

export interface PurchaseReservedInstancesOfferingRequest {
    
    InstanceCount: number | undefined;
    
    ReservedInstancesOfferingId: string | undefined;
    
    DryRun?: boolean;
    
    LimitPrice?: ReservedInstanceLimitPrice;
    
    PurchaseTime?: Date;
}
export declare namespace PurchaseReservedInstancesOfferingRequest {
    
    const filterSensitiveLog: (obj: PurchaseReservedInstancesOfferingRequest) => any;
}

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

export interface PurchaseRequest {
    
    InstanceCount: number | undefined;
    
    PurchaseToken: string | undefined;
}
export declare namespace PurchaseRequest {
    
    const filterSensitiveLog: (obj: PurchaseRequest) => any;
}

export interface PurchaseScheduledInstancesRequest {
    
    ClientToken?: string;
    
    DryRun?: boolean;
    
    PurchaseRequests: PurchaseRequest[] | undefined;
}
export declare namespace PurchaseScheduledInstancesRequest {
    
    const filterSensitiveLog: (obj: PurchaseScheduledInstancesRequest) => any;
}

export interface PurchaseScheduledInstancesResult {
    
    ScheduledInstanceSet?: ScheduledInstance[];
}
export declare namespace PurchaseScheduledInstancesResult {
    
    const filterSensitiveLog: (obj: PurchaseScheduledInstancesResult) => any;
}
export interface RebootInstancesRequest {
    
    InstanceIds: string[] | undefined;
    
    DryRun?: boolean;
}
export declare namespace RebootInstancesRequest {
    
    const filterSensitiveLog: (obj: RebootInstancesRequest) => any;
}

export interface RegisterImageRequest {
    
    ImageLocation?: string;
    
    Architecture?: ArchitectureValues | string;
    
    BlockDeviceMappings?: BlockDeviceMapping[];
    
    Description?: string;
    
    DryRun?: boolean;
    
    EnaSupport?: boolean;
    
    KernelId?: string;
    
    Name: string | undefined;
    
    BillingProducts?: string[];
    
    RamdiskId?: string;
    
    RootDeviceName?: string;
    
    SriovNetSupport?: string;
    
    VirtualizationType?: string;
    
    BootMode?: BootModeValues | string;
}
export declare namespace RegisterImageRequest {
    
    const filterSensitiveLog: (obj: RegisterImageRequest) => any;
}

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

export interface RegisterInstanceTagAttributeRequest {
    
    IncludeAllTagsOfInstance?: boolean;
    
    InstanceTagKeys?: string[];
}
export declare namespace RegisterInstanceTagAttributeRequest {
    
    const filterSensitiveLog: (obj: RegisterInstanceTagAttributeRequest) => any;
}
export interface RegisterInstanceEventNotificationAttributesRequest {
    
    DryRun?: boolean;
    
    InstanceTagAttribute?: RegisterInstanceTagAttributeRequest;
}
export declare namespace RegisterInstanceEventNotificationAttributesRequest {
    
    const filterSensitiveLog: (obj: RegisterInstanceEventNotificationAttributesRequest) => any;
}
export interface RegisterInstanceEventNotificationAttributesResult {
    
    InstanceTagAttribute?: InstanceTagNotificationAttribute;
}
export declare namespace RegisterInstanceEventNotificationAttributesResult {
    
    const filterSensitiveLog: (obj: RegisterInstanceEventNotificationAttributesResult) => any;
}
export interface RegisterTransitGatewayMulticastGroupMembersRequest {
    
    TransitGatewayMulticastDomainId?: string;
    
    GroupIpAddress?: string;
    
    NetworkInterfaceIds?: string[];
    
    DryRun?: boolean;
}
export declare namespace RegisterTransitGatewayMulticastGroupMembersRequest {
    
    const filterSensitiveLog: (obj: RegisterTransitGatewayMulticastGroupMembersRequest) => any;
}

export interface TransitGatewayMulticastRegisteredGroupMembers {
    
    TransitGatewayMulticastDomainId?: string;
    
    RegisteredNetworkInterfaceIds?: string[];
    
    GroupIpAddress?: string;
}
export declare namespace TransitGatewayMulticastRegisteredGroupMembers {
    
    const filterSensitiveLog: (obj: TransitGatewayMulticastRegisteredGroupMembers) => any;
}
export interface RegisterTransitGatewayMulticastGroupMembersResult {
    
    RegisteredMulticastGroupMembers?: TransitGatewayMulticastRegisteredGroupMembers;
}
export declare namespace RegisterTransitGatewayMulticastGroupMembersResult {
    
    const filterSensitiveLog: (obj: RegisterTransitGatewayMulticastGroupMembersResult) => any;
}
export interface RegisterTransitGatewayMulticastGroupSourcesRequest {
    
    TransitGatewayMulticastDomainId?: string;
    
    GroupIpAddress?: string;
    
    NetworkInterfaceIds?: string[];
    
    DryRun?: boolean;
}
export declare namespace RegisterTransitGatewayMulticastGroupSourcesRequest {
    
    const filterSensitiveLog: (obj: RegisterTransitGatewayMulticastGroupSourcesRequest) => any;
}

export interface TransitGatewayMulticastRegisteredGroupSources {
    
    TransitGatewayMulticastDomainId?: string;
    
    RegisteredNetworkInterfaceIds?: string[];
    
    GroupIpAddress?: string;
}
export declare namespace TransitGatewayMulticastRegisteredGroupSources {
    
    const filterSensitiveLog: (obj: TransitGatewayMulticastRegisteredGroupSources) => any;
}
export interface RegisterTransitGatewayMulticastGroupSourcesResult {
    
    RegisteredMulticastGroupSources?: TransitGatewayMulticastRegisteredGroupSources;
}
export declare namespace RegisterTransitGatewayMulticastGroupSourcesResult {
    
    const filterSensitiveLog: (obj: RegisterTransitGatewayMulticastGroupSourcesResult) => any;
}
export interface RejectTransitGatewayMulticastDomainAssociationsRequest {
    
    TransitGatewayMulticastDomainId?: string;
    
    TransitGatewayAttachmentId?: string;
    
    SubnetIds?: string[];
    
    DryRun?: boolean;
}
export declare namespace RejectTransitGatewayMulticastDomainAssociationsRequest {
    
    const filterSensitiveLog: (obj: RejectTransitGatewayMulticastDomainAssociationsRequest) => any;
}
export interface RejectTransitGatewayMulticastDomainAssociationsResult {
    
    Associations?: TransitGatewayMulticastDomainAssociations;
}
export declare namespace RejectTransitGatewayMulticastDomainAssociationsResult {
    
    const filterSensitiveLog: (obj: RejectTransitGatewayMulticastDomainAssociationsResult) => any;
}
export interface RejectTransitGatewayPeeringAttachmentRequest {
    
    TransitGatewayAttachmentId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace RejectTransitGatewayPeeringAttachmentRequest {
    
    const filterSensitiveLog: (obj: RejectTransitGatewayPeeringAttachmentRequest) => any;
}
export interface RejectTransitGatewayPeeringAttachmentResult {
    
    TransitGatewayPeeringAttachment?: TransitGatewayPeeringAttachment;
}
export declare namespace RejectTransitGatewayPeeringAttachmentResult {
    
    const filterSensitiveLog: (obj: RejectTransitGatewayPeeringAttachmentResult) => any;
}
export interface RejectTransitGatewayVpcAttachmentRequest {
    
    TransitGatewayAttachmentId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace RejectTransitGatewayVpcAttachmentRequest {
    
    const filterSensitiveLog: (obj: RejectTransitGatewayVpcAttachmentRequest) => any;
}
export interface RejectTransitGatewayVpcAttachmentResult {
    
    TransitGatewayVpcAttachment?: TransitGatewayVpcAttachment;
}
export declare namespace RejectTransitGatewayVpcAttachmentResult {
    
    const filterSensitiveLog: (obj: RejectTransitGatewayVpcAttachmentResult) => any;
}
export interface RejectVpcEndpointConnectionsRequest {
    
    DryRun?: boolean;
    
    ServiceId: string | undefined;
    
    VpcEndpointIds: string[] | undefined;
}
export declare namespace RejectVpcEndpointConnectionsRequest {
    
    const filterSensitiveLog: (obj: RejectVpcEndpointConnectionsRequest) => any;
}
export interface RejectVpcEndpointConnectionsResult {
    
    Unsuccessful?: UnsuccessfulItem[];
}
export declare namespace RejectVpcEndpointConnectionsResult {
    
    const filterSensitiveLog: (obj: RejectVpcEndpointConnectionsResult) => any;
}
export interface RejectVpcPeeringConnectionRequest {
    
    DryRun?: boolean;
    
    VpcPeeringConnectionId: string | undefined;
}
export declare namespace RejectVpcPeeringConnectionRequest {
    
    const filterSensitiveLog: (obj: RejectVpcPeeringConnectionRequest) => any;
}
export interface RejectVpcPeeringConnectionResult {
    
    Return?: boolean;
}
export declare namespace RejectVpcPeeringConnectionResult {
    
    const filterSensitiveLog: (obj: RejectVpcPeeringConnectionResult) => any;
}
export interface ReleaseAddressRequest {
    
    AllocationId?: string;
    
    PublicIp?: string;
    
    NetworkBorderGroup?: string;
    
    DryRun?: boolean;
}
export declare namespace ReleaseAddressRequest {
    
    const filterSensitiveLog: (obj: ReleaseAddressRequest) => any;
}
export interface ReleaseHostsRequest {
    
    HostIds: string[] | undefined;
}
export declare namespace ReleaseHostsRequest {
    
    const filterSensitiveLog: (obj: ReleaseHostsRequest) => any;
}
export interface ReleaseHostsResult {
    
    Successful?: string[];
    
    Unsuccessful?: UnsuccessfulItem[];
}
export declare namespace ReleaseHostsResult {
    
    const filterSensitiveLog: (obj: ReleaseHostsResult) => any;
}
export interface ReplaceIamInstanceProfileAssociationRequest {
    
    IamInstanceProfile: IamInstanceProfileSpecification | undefined;
    
    AssociationId: string | undefined;
}
export declare namespace ReplaceIamInstanceProfileAssociationRequest {
    
    const filterSensitiveLog: (obj: ReplaceIamInstanceProfileAssociationRequest) => any;
}
export interface ReplaceIamInstanceProfileAssociationResult {
    
    IamInstanceProfileAssociation?: IamInstanceProfileAssociation;
}
export declare namespace ReplaceIamInstanceProfileAssociationResult {
    
    const filterSensitiveLog: (obj: ReplaceIamInstanceProfileAssociationResult) => any;
}
export interface ReplaceNetworkAclAssociationRequest {
    
    AssociationId: string | undefined;
    
    DryRun?: boolean;
    
    NetworkAclId: string | undefined;
}
export declare namespace ReplaceNetworkAclAssociationRequest {
    
    const filterSensitiveLog: (obj: ReplaceNetworkAclAssociationRequest) => any;
}
export interface ReplaceNetworkAclAssociationResult {
    
    NewAssociationId?: string;
}
export declare namespace ReplaceNetworkAclAssociationResult {
    
    const filterSensitiveLog: (obj: ReplaceNetworkAclAssociationResult) => any;
}
export interface ReplaceNetworkAclEntryRequest {
    
    CidrBlock?: string;
    
    DryRun?: boolean;
    
    Egress: boolean | undefined;
    
    IcmpTypeCode?: IcmpTypeCode;
    
    Ipv6CidrBlock?: string;
    
    NetworkAclId: string | undefined;
    
    PortRange?: PortRange;
    
    Protocol: string | undefined;
    
    RuleAction: RuleAction | string | undefined;
    
    RuleNumber: number | undefined;
}
export declare namespace ReplaceNetworkAclEntryRequest {
    
    const filterSensitiveLog: (obj: ReplaceNetworkAclEntryRequest) => any;
}
export interface ReplaceRouteRequest {
    
    DestinationCidrBlock?: string;
    
    DestinationIpv6CidrBlock?: string;
    
    DestinationPrefixListId?: string;
    
    DryRun?: boolean;
    
    VpcEndpointId?: string;
    
    EgressOnlyInternetGatewayId?: string;
    
    GatewayId?: string;
    
    InstanceId?: string;
    
    LocalTarget?: boolean;
    
    NatGatewayId?: string;
    
    TransitGatewayId?: string;
    
    LocalGatewayId?: string;
    
    CarrierGatewayId?: string;
    
    NetworkInterfaceId?: string;
    
    RouteTableId: string | undefined;
    
    VpcPeeringConnectionId?: string;
}
export declare namespace ReplaceRouteRequest {
    
    const filterSensitiveLog: (obj: ReplaceRouteRequest) => any;
}
export interface ReplaceRouteTableAssociationRequest {
    
    AssociationId: string | undefined;
    
    DryRun?: boolean;
    
    RouteTableId: string | undefined;
}
export declare namespace ReplaceRouteTableAssociationRequest {
    
    const filterSensitiveLog: (obj: ReplaceRouteTableAssociationRequest) => any;
}
export interface ReplaceRouteTableAssociationResult {
    
    NewAssociationId?: string;
    
    AssociationState?: RouteTableAssociationState;
}
export declare namespace ReplaceRouteTableAssociationResult {
    
    const filterSensitiveLog: (obj: ReplaceRouteTableAssociationResult) => any;
}
export interface ReplaceTransitGatewayRouteRequest {
    
    DestinationCidrBlock: string | undefined;
    
    TransitGatewayRouteTableId: string | undefined;
    
    TransitGatewayAttachmentId?: string;
    
    Blackhole?: boolean;
    
    DryRun?: boolean;
}
export declare namespace ReplaceTransitGatewayRouteRequest {
    
    const filterSensitiveLog: (obj: ReplaceTransitGatewayRouteRequest) => any;
}
export interface ReplaceTransitGatewayRouteResult {
    
    Route?: TransitGatewayRoute;
}
export declare namespace ReplaceTransitGatewayRouteResult {
    
    const filterSensitiveLog: (obj: ReplaceTransitGatewayRouteResult) => any;
}
export declare type ReportInstanceReasonCodes = "instance-stuck-in-state" | "not-accepting-credentials" | "other" | "password-not-available" | "performance-ebs-volume" | "performance-instance-store" | "performance-network" | "performance-other" | "unresponsive";
export declare type ReportStatusType = "impaired" | "ok";
export interface ReportInstanceStatusRequest {
    
    Description?: string;
    
    DryRun?: boolean;
    
    EndTime?: Date;
    
    Instances: string[] | undefined;
    
    ReasonCodes: (ReportInstanceReasonCodes | string)[] | undefined;
    
    StartTime?: Date;
    
    Status: ReportStatusType | string | undefined;
}
export declare namespace ReportInstanceStatusRequest {
    
    const filterSensitiveLog: (obj: ReportInstanceStatusRequest) => any;
}

export interface RequestSpotFleetRequest {
    
    DryRun?: boolean;
    
    SpotFleetRequestConfig: SpotFleetRequestConfigData | undefined;
}
export declare namespace RequestSpotFleetRequest {
    
    const filterSensitiveLog: (obj: RequestSpotFleetRequest) => any;
}

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

export interface RequestSpotLaunchSpecification {
    
    SecurityGroupIds?: string[];
    
    SecurityGroups?: string[];
    
    AddressingType?: string;
    
    BlockDeviceMappings?: BlockDeviceMapping[];
    
    EbsOptimized?: boolean;
    
    IamInstanceProfile?: IamInstanceProfileSpecification;
    
    ImageId?: string;
    
    InstanceType?: _InstanceType | string;
    
    KernelId?: string;
    
    KeyName?: string;
    
    Monitoring?: RunInstancesMonitoringEnabled;
    
    NetworkInterfaces?: InstanceNetworkInterfaceSpecification[];
    
    Placement?: SpotPlacement;
    
    RamdiskId?: string;
    
    SubnetId?: string;
    
    UserData?: string;
}
export declare namespace RequestSpotLaunchSpecification {
    
    const filterSensitiveLog: (obj: RequestSpotLaunchSpecification) => any;
}

export interface RequestSpotInstancesRequest {
    
    AvailabilityZoneGroup?: string;
    
    BlockDurationMinutes?: number;
    
    ClientToken?: string;
    
    DryRun?: boolean;
    
    InstanceCount?: number;
    
    LaunchGroup?: string;
    
    LaunchSpecification?: RequestSpotLaunchSpecification;
    
    SpotPrice?: string;
    
    Type?: SpotInstanceType | string;
    
    ValidFrom?: Date;
    
    ValidUntil?: Date;
    
    TagSpecifications?: TagSpecification[];
    
    InstanceInterruptionBehavior?: InstanceInterruptionBehavior | string;
}
export declare namespace RequestSpotInstancesRequest {
    
    const filterSensitiveLog: (obj: RequestSpotInstancesRequest) => any;
}

export interface RequestSpotInstancesResult {
    
    SpotInstanceRequests?: SpotInstanceRequest[];
}
export declare namespace RequestSpotInstancesResult {
    
    const filterSensitiveLog: (obj: RequestSpotInstancesResult) => any;
}
export interface ResetAddressAttributeRequest {
    
    AllocationId: string | undefined;
    
    Attribute: AddressAttributeName | string | undefined;
    
    DryRun?: boolean;
}
export declare namespace ResetAddressAttributeRequest {
    
    const filterSensitiveLog: (obj: ResetAddressAttributeRequest) => any;
}
export interface ResetAddressAttributeResult {
    
    Address?: AddressAttribute;
}
export declare namespace ResetAddressAttributeResult {
    
    const filterSensitiveLog: (obj: ResetAddressAttributeResult) => any;
}
export interface ResetEbsDefaultKmsKeyIdRequest {
    
    DryRun?: boolean;
}
export declare namespace ResetEbsDefaultKmsKeyIdRequest {
    
    const filterSensitiveLog: (obj: ResetEbsDefaultKmsKeyIdRequest) => any;
}
export interface ResetEbsDefaultKmsKeyIdResult {
    
    KmsKeyId?: string;
}
export declare namespace ResetEbsDefaultKmsKeyIdResult {
    
    const filterSensitiveLog: (obj: ResetEbsDefaultKmsKeyIdResult) => any;
}
export declare type ResetFpgaImageAttributeName = "loadPermission";
export interface ResetFpgaImageAttributeRequest {
    
    DryRun?: boolean;
    
    FpgaImageId: string | undefined;
    
    Attribute?: ResetFpgaImageAttributeName | string;
}
export declare namespace ResetFpgaImageAttributeRequest {
    
    const filterSensitiveLog: (obj: ResetFpgaImageAttributeRequest) => any;
}
export interface ResetFpgaImageAttributeResult {
    
    Return?: boolean;
}
export declare namespace ResetFpgaImageAttributeResult {
    
    const filterSensitiveLog: (obj: ResetFpgaImageAttributeResult) => any;
}
export declare type ResetImageAttributeName = "launchPermission";

export interface ResetImageAttributeRequest {
    
    Attribute: ResetImageAttributeName | string | undefined;
    
    ImageId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace ResetImageAttributeRequest {
    
    const filterSensitiveLog: (obj: ResetImageAttributeRequest) => any;
}
export interface ResetInstanceAttributeRequest {
    
    Attribute: InstanceAttributeName | string | undefined;
    
    DryRun?: boolean;
    
    InstanceId: string | undefined;
}
export declare namespace ResetInstanceAttributeRequest {
    
    const filterSensitiveLog: (obj: ResetInstanceAttributeRequest) => any;
}

export interface ResetNetworkInterfaceAttributeRequest {
    
    DryRun?: boolean;
    
    NetworkInterfaceId: string | undefined;
    
    SourceDestCheck?: string;
}
export declare namespace ResetNetworkInterfaceAttributeRequest {
    
    const filterSensitiveLog: (obj: ResetNetworkInterfaceAttributeRequest) => any;
}
export interface ResetSnapshotAttributeRequest {
    
    Attribute: SnapshotAttributeName | string | undefined;
    
    SnapshotId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace ResetSnapshotAttributeRequest {
    
    const filterSensitiveLog: (obj: ResetSnapshotAttributeRequest) => any;
}
export interface RestoreAddressToClassicRequest {
    
    DryRun?: boolean;
    
    PublicIp: string | undefined;
}
export declare namespace RestoreAddressToClassicRequest {
    
    const filterSensitiveLog: (obj: RestoreAddressToClassicRequest) => any;
}
export interface RestoreAddressToClassicResult {
    
    PublicIp?: string;
    
    Status?: Status | string;
}
export declare namespace RestoreAddressToClassicResult {
    
    const filterSensitiveLog: (obj: RestoreAddressToClassicResult) => any;
}
export interface RestoreManagedPrefixListVersionRequest {
    
    DryRun?: boolean;
    
    PrefixListId: string | undefined;
    
    PreviousVersion: number | undefined;
    
    CurrentVersion: number | undefined;
}
export declare namespace RestoreManagedPrefixListVersionRequest {
    
    const filterSensitiveLog: (obj: RestoreManagedPrefixListVersionRequest) => any;
}
export interface RestoreManagedPrefixListVersionResult {
    
    PrefixList?: ManagedPrefixList;
}
export declare namespace RestoreManagedPrefixListVersionResult {
    
    const filterSensitiveLog: (obj: RestoreManagedPrefixListVersionResult) => any;
}
export interface RevokeClientVpnIngressRequest {
    
    ClientVpnEndpointId: string | undefined;
    
    TargetNetworkCidr: string | undefined;
    
    AccessGroupId?: string;
    
    RevokeAllGroups?: boolean;
    
    DryRun?: boolean;
}
export declare namespace RevokeClientVpnIngressRequest {
    
    const filterSensitiveLog: (obj: RevokeClientVpnIngressRequest) => any;
}
export interface RevokeClientVpnIngressResult {
    
    Status?: ClientVpnAuthorizationRuleStatus;
}
export declare namespace RevokeClientVpnIngressResult {
    
    const filterSensitiveLog: (obj: RevokeClientVpnIngressResult) => any;
}
export interface RevokeSecurityGroupEgressRequest {
    
    DryRun?: boolean;
    
    GroupId: string | undefined;
    
    IpPermissions?: IpPermission[];
    
    SecurityGroupRuleIds?: string[];
    
    CidrIp?: string;
    
    FromPort?: number;
    
    IpProtocol?: string;
    
    ToPort?: number;
    
    SourceSecurityGroupName?: string;
    
    SourceSecurityGroupOwnerId?: string;
}
export declare namespace RevokeSecurityGroupEgressRequest {
    
    const filterSensitiveLog: (obj: RevokeSecurityGroupEgressRequest) => any;
}
export interface RevokeSecurityGroupEgressResult {
    
    Return?: boolean;
    
    UnknownIpPermissions?: IpPermission[];
}
export declare namespace RevokeSecurityGroupEgressResult {
    
    const filterSensitiveLog: (obj: RevokeSecurityGroupEgressResult) => any;
}
export interface RevokeSecurityGroupIngressRequest {
    
    CidrIp?: string;
    
    FromPort?: number;
    
    GroupId?: string;
    
    GroupName?: string;
    
    IpPermissions?: IpPermission[];
    
    IpProtocol?: string;
    
    SourceSecurityGroupName?: string;
    
    SourceSecurityGroupOwnerId?: string;
    
    ToPort?: number;
    
    DryRun?: boolean;
    
    SecurityGroupRuleIds?: string[];
}
export declare namespace RevokeSecurityGroupIngressRequest {
    
    const filterSensitiveLog: (obj: RevokeSecurityGroupIngressRequest) => any;
}
export interface RevokeSecurityGroupIngressResult {
    
    Return?: boolean;
    
    UnknownIpPermissions?: IpPermission[];
}
export declare namespace RevokeSecurityGroupIngressResult {
    
    const filterSensitiveLog: (obj: RevokeSecurityGroupIngressResult) => any;
}

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

export interface ElasticInferenceAccelerator {
    
    Type: string | undefined;
    
    Count?: number;
}
export declare namespace ElasticInferenceAccelerator {
    
    const filterSensitiveLog: (obj: ElasticInferenceAccelerator) => any;
}

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

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

export interface SpotMarketOptions {
    
    MaxPrice?: string;
    
    SpotInstanceType?: SpotInstanceType | string;
    
    BlockDurationMinutes?: number;
    
    ValidUntil?: Date;
    
    InstanceInterruptionBehavior?: InstanceInterruptionBehavior | string;
}
export declare namespace SpotMarketOptions {
    
    const filterSensitiveLog: (obj: SpotMarketOptions) => any;
}

export interface InstanceMarketOptionsRequest {
    
    MarketType?: MarketType | string;
    
    SpotOptions?: SpotMarketOptions;
}
export declare namespace InstanceMarketOptionsRequest {
    
    const filterSensitiveLog: (obj: InstanceMarketOptionsRequest) => any;
}

export interface LaunchTemplateSpecification {
    
    LaunchTemplateId?: string;
    
    LaunchTemplateName?: string;
    
    Version?: string;
}
export declare namespace LaunchTemplateSpecification {
    
    const filterSensitiveLog: (obj: LaunchTemplateSpecification) => any;
}

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

export interface InstanceMetadataOptionsRequest {
    
    HttpTokens?: HttpTokensState | string;
    
    HttpPutResponseHopLimit?: number;
    
    HttpEndpoint?: InstanceMetadataEndpointState | string;
    
    HttpProtocolIpv6?: InstanceMetadataProtocolState | string;
}
export declare namespace InstanceMetadataOptionsRequest {
    
    const filterSensitiveLog: (obj: InstanceMetadataOptionsRequest) => any;
}
export interface RunInstancesRequest {
    
    BlockDeviceMappings?: BlockDeviceMapping[];
    
    ImageId?: string;
    
    InstanceType?: _InstanceType | string;
    
    Ipv6AddressCount?: number;
    
    Ipv6Addresses?: InstanceIpv6Address[];
    
    KernelId?: string;
    
    KeyName?: string;
    
    MaxCount: number | undefined;
    
    MinCount: number | undefined;
    
    Monitoring?: RunInstancesMonitoringEnabled;
    
    Placement?: Placement;
    
    RamdiskId?: string;
    
    SecurityGroupIds?: string[];
    
    SecurityGroups?: string[];
    
    SubnetId?: string;
    
    UserData?: string;
    
    AdditionalInfo?: string;
    
    ClientToken?: string;
    
    DisableApiTermination?: boolean;
    
    DryRun?: boolean;
    
    EbsOptimized?: boolean;
    
    IamInstanceProfile?: IamInstanceProfileSpecification;
    
    InstanceInitiatedShutdownBehavior?: ShutdownBehavior | string;
    
    NetworkInterfaces?: InstanceNetworkInterfaceSpecification[];
    
    PrivateIpAddress?: string;
    
    ElasticGpuSpecification?: ElasticGpuSpecification[];
    
    ElasticInferenceAccelerators?: ElasticInferenceAccelerator[];
    
    TagSpecifications?: TagSpecification[];
    
    LaunchTemplate?: LaunchTemplateSpecification;
    
    InstanceMarketOptions?: InstanceMarketOptionsRequest;
    
    CreditSpecification?: CreditSpecificationRequest;
    
    CpuOptions?: CpuOptionsRequest;
    
    CapacityReservationSpecification?: CapacityReservationSpecification;
    
    HibernationOptions?: HibernationOptionsRequest;
    
    LicenseSpecifications?: LicenseConfigurationRequest[];
    
    MetadataOptions?: InstanceMetadataOptionsRequest;
    
    EnclaveOptions?: EnclaveOptionsRequest;
}
export declare namespace RunInstancesRequest {
    
    const filterSensitiveLog: (obj: RunInstancesRequest) => any;
}

export interface ScheduledInstancesEbs {
    
    DeleteOnTermination?: boolean;
    
    Encrypted?: boolean;
    
    Iops?: number;
    
    SnapshotId?: string;
    
    VolumeSize?: number;
    
    VolumeType?: string;
}
export declare namespace ScheduledInstancesEbs {
    
    const filterSensitiveLog: (obj: ScheduledInstancesEbs) => any;
}

export interface ScheduledInstancesBlockDeviceMapping {
    
    DeviceName?: string;
    
    Ebs?: ScheduledInstancesEbs;
    
    NoDevice?: string;
    
    VirtualName?: string;
}
export declare namespace ScheduledInstancesBlockDeviceMapping {
    
    const filterSensitiveLog: (obj: ScheduledInstancesBlockDeviceMapping) => any;
}

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

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

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

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

export interface ScheduledInstancesNetworkInterface {
    
    AssociatePublicIpAddress?: boolean;
    
    DeleteOnTermination?: boolean;
    
    Description?: string;
    
    DeviceIndex?: number;
    
    Groups?: string[];
    
    Ipv6AddressCount?: number;
    
    Ipv6Addresses?: ScheduledInstancesIpv6Address[];
    
    NetworkInterfaceId?: string;
    
    PrivateIpAddress?: string;
    
    PrivateIpAddressConfigs?: ScheduledInstancesPrivateIpAddressConfig[];
    
    SecondaryPrivateIpAddressCount?: number;
    
    SubnetId?: string;
}
export declare namespace ScheduledInstancesNetworkInterface {
    
    const filterSensitiveLog: (obj: ScheduledInstancesNetworkInterface) => any;
}

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

export interface ScheduledInstancesLaunchSpecification {
    
    BlockDeviceMappings?: ScheduledInstancesBlockDeviceMapping[];
    
    EbsOptimized?: boolean;
    
    IamInstanceProfile?: ScheduledInstancesIamInstanceProfile;
    
    ImageId: string | undefined;
    
    InstanceType?: string;
    
    KernelId?: string;
    
    KeyName?: string;
    
    Monitoring?: ScheduledInstancesMonitoring;
    
    NetworkInterfaces?: ScheduledInstancesNetworkInterface[];
    
    Placement?: ScheduledInstancesPlacement;
    
    RamdiskId?: string;
    
    SecurityGroupIds?: string[];
    
    SubnetId?: string;
    
    UserData?: string;
}
export declare namespace ScheduledInstancesLaunchSpecification {
    
    const filterSensitiveLog: (obj: ScheduledInstancesLaunchSpecification) => any;
}

export interface RunScheduledInstancesRequest {
    
    ClientToken?: string;
    
    DryRun?: boolean;
    
    InstanceCount?: number;
    
    LaunchSpecification: ScheduledInstancesLaunchSpecification | undefined;
    
    ScheduledInstanceId: string | undefined;
}
export declare namespace RunScheduledInstancesRequest {
    
    const filterSensitiveLog: (obj: RunScheduledInstancesRequest) => any;
}

export interface RunScheduledInstancesResult {
    
    InstanceIdSet?: string[];
}
export declare namespace RunScheduledInstancesResult {
    
    const filterSensitiveLog: (obj: RunScheduledInstancesResult) => any;
}
export interface SearchLocalGatewayRoutesRequest {
    
    LocalGatewayRouteTableId: string | undefined;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace SearchLocalGatewayRoutesRequest {
    
    const filterSensitiveLog: (obj: SearchLocalGatewayRoutesRequest) => any;
}
export interface SearchLocalGatewayRoutesResult {
    
    Routes?: LocalGatewayRoute[];
    
    NextToken?: string;
}
export declare namespace SearchLocalGatewayRoutesResult {
    
    const filterSensitiveLog: (obj: SearchLocalGatewayRoutesResult) => any;
}
export interface SearchTransitGatewayMulticastGroupsRequest {
    
    TransitGatewayMulticastDomainId?: string;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace SearchTransitGatewayMulticastGroupsRequest {
    
    const filterSensitiveLog: (obj: SearchTransitGatewayMulticastGroupsRequest) => any;
}
export declare type MembershipType = "igmp" | "static";

export interface TransitGatewayMulticastGroup {
    
    GroupIpAddress?: string;
    
    TransitGatewayAttachmentId?: string;
    
    SubnetId?: string;
    
    ResourceId?: string;
    
    ResourceType?: TransitGatewayAttachmentResourceType | string;
    
    ResourceOwnerId?: string;
    
    NetworkInterfaceId?: string;
    
    GroupMember?: boolean;
    
    GroupSource?: boolean;
    
    MemberType?: MembershipType | string;
    
    SourceType?: MembershipType | string;
}
export declare namespace TransitGatewayMulticastGroup {
    
    const filterSensitiveLog: (obj: TransitGatewayMulticastGroup) => any;
}
export interface SearchTransitGatewayMulticastGroupsResult {
    
    MulticastGroups?: TransitGatewayMulticastGroup[];
    
    NextToken?: string;
}
export declare namespace SearchTransitGatewayMulticastGroupsResult {
    
    const filterSensitiveLog: (obj: SearchTransitGatewayMulticastGroupsResult) => any;
}
export interface SearchTransitGatewayRoutesRequest {
    
    TransitGatewayRouteTableId: string | undefined;
    
    Filters: Filter[] | undefined;
    
    MaxResults?: number;
    
    DryRun?: boolean;
}
export declare namespace SearchTransitGatewayRoutesRequest {
    
    const filterSensitiveLog: (obj: SearchTransitGatewayRoutesRequest) => any;
}
export interface SearchTransitGatewayRoutesResult {
    
    Routes?: TransitGatewayRoute[];
    
    AdditionalRoutesAvailable?: boolean;
}
export declare namespace SearchTransitGatewayRoutesResult {
    
    const filterSensitiveLog: (obj: SearchTransitGatewayRoutesResult) => any;
}
export interface SendDiagnosticInterruptRequest {
    
    InstanceId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace SendDiagnosticInterruptRequest {
    
    const filterSensitiveLog: (obj: SendDiagnosticInterruptRequest) => any;
}
export interface StartInstancesRequest {
    
    InstanceIds: string[] | undefined;
    
    AdditionalInfo?: string;
    
    DryRun?: boolean;
}
export declare namespace StartInstancesRequest {
    
    const filterSensitiveLog: (obj: StartInstancesRequest) => any;
}

export interface InstanceStateChange {
    
    CurrentState?: InstanceState;
    
    InstanceId?: string;
    
    PreviousState?: InstanceState;
}
export declare namespace InstanceStateChange {
    
    const filterSensitiveLog: (obj: InstanceStateChange) => any;
}
export interface StartInstancesResult {
    
    StartingInstances?: InstanceStateChange[];
}
export declare namespace StartInstancesResult {
    
    const filterSensitiveLog: (obj: StartInstancesResult) => any;
}
export interface StartNetworkInsightsAnalysisRequest {
    
    NetworkInsightsPathId: string | undefined;
    
    FilterInArns?: string[];
    
    DryRun?: boolean;
    
    TagSpecifications?: TagSpecification[];
    
    ClientToken?: string;
}
export declare namespace StartNetworkInsightsAnalysisRequest {
    
    const filterSensitiveLog: (obj: StartNetworkInsightsAnalysisRequest) => any;
}
export interface StartNetworkInsightsAnalysisResult {
    
    NetworkInsightsAnalysis?: NetworkInsightsAnalysis;
}
export declare namespace StartNetworkInsightsAnalysisResult {
    
    const filterSensitiveLog: (obj: StartNetworkInsightsAnalysisResult) => any;
}
export interface StartVpcEndpointServicePrivateDnsVerificationRequest {
    
    DryRun?: boolean;
    
    ServiceId: string | undefined;
}
export declare namespace StartVpcEndpointServicePrivateDnsVerificationRequest {
    
    const filterSensitiveLog: (obj: StartVpcEndpointServicePrivateDnsVerificationRequest) => any;
}
export interface StartVpcEndpointServicePrivateDnsVerificationResult {
    
    ReturnValue?: boolean;
}
export declare namespace StartVpcEndpointServicePrivateDnsVerificationResult {
    
    const filterSensitiveLog: (obj: StartVpcEndpointServicePrivateDnsVerificationResult) => any;
}
export interface StopInstancesRequest {
    
    InstanceIds: string[] | undefined;
    
    Hibernate?: boolean;
    
    DryRun?: boolean;
    
    Force?: boolean;
}
export declare namespace StopInstancesRequest {
    
    const filterSensitiveLog: (obj: StopInstancesRequest) => any;
}
export interface StopInstancesResult {
    
    StoppingInstances?: InstanceStateChange[];
}
export declare namespace StopInstancesResult {
    
    const filterSensitiveLog: (obj: StopInstancesResult) => any;
}
export interface TerminateClientVpnConnectionsRequest {
    
    ClientVpnEndpointId: string | undefined;
    
    ConnectionId?: string;
    
    Username?: string;
    
    DryRun?: boolean;
}
export declare namespace TerminateClientVpnConnectionsRequest {
    
    const filterSensitiveLog: (obj: TerminateClientVpnConnectionsRequest) => any;
}

export interface TerminateConnectionStatus {
    
    ConnectionId?: string;
    
    PreviousStatus?: ClientVpnConnectionStatus;
    
    CurrentStatus?: ClientVpnConnectionStatus;
}
export declare namespace TerminateConnectionStatus {
    
    const filterSensitiveLog: (obj: TerminateConnectionStatus) => any;
}
export interface TerminateClientVpnConnectionsResult {
    
    ClientVpnEndpointId?: string;
    
    Username?: string;
    
    ConnectionStatuses?: TerminateConnectionStatus[];
}
export declare namespace TerminateClientVpnConnectionsResult {
    
    const filterSensitiveLog: (obj: TerminateClientVpnConnectionsResult) => any;
}
export interface TerminateInstancesRequest {
    
    InstanceIds: string[] | undefined;
    
    DryRun?: boolean;
}
export declare namespace TerminateInstancesRequest {
    
    const filterSensitiveLog: (obj: TerminateInstancesRequest) => any;
}
export interface TerminateInstancesResult {
    
    TerminatingInstances?: InstanceStateChange[];
}
export declare namespace TerminateInstancesResult {
    
    const filterSensitiveLog: (obj: TerminateInstancesResult) => any;
}
export interface UnassignIpv6AddressesRequest {
    
    Ipv6Addresses?: string[];
    
    Ipv6Prefixes?: string[];
    
    NetworkInterfaceId: string | undefined;
}
export declare namespace UnassignIpv6AddressesRequest {
    
    const filterSensitiveLog: (obj: UnassignIpv6AddressesRequest) => any;
}
export interface UnassignIpv6AddressesResult {
    
    NetworkInterfaceId?: string;
    
    UnassignedIpv6Addresses?: string[];
    
    UnassignedIpv6Prefixes?: string[];
}
export declare namespace UnassignIpv6AddressesResult {
    
    const filterSensitiveLog: (obj: UnassignIpv6AddressesResult) => any;
}

export interface UnassignPrivateIpAddressesRequest {
    
    NetworkInterfaceId: string | undefined;
    
    PrivateIpAddresses?: string[];
    
    Ipv4Prefixes?: string[];
}
export declare namespace UnassignPrivateIpAddressesRequest {
    
    const filterSensitiveLog: (obj: UnassignPrivateIpAddressesRequest) => any;
}
export interface UnmonitorInstancesRequest {
    
    InstanceIds: string[] | undefined;
    
    DryRun?: boolean;
}
export declare namespace UnmonitorInstancesRequest {
    
    const filterSensitiveLog: (obj: UnmonitorInstancesRequest) => any;
}
export interface UnmonitorInstancesResult {
    
    InstanceMonitorings?: InstanceMonitoring[];
}
export declare namespace UnmonitorInstancesResult {
    
    const filterSensitiveLog: (obj: UnmonitorInstancesResult) => any;
}

export interface SecurityGroupRuleDescription {
    
    SecurityGroupRuleId?: string;
    
    Description?: string;
}
export declare namespace SecurityGroupRuleDescription {
    
    const filterSensitiveLog: (obj: SecurityGroupRuleDescription) => any;
}
export interface UpdateSecurityGroupRuleDescriptionsEgressRequest {
    
    DryRun?: boolean;
    
    GroupId?: string;
    
    GroupName?: string;
    
    IpPermissions?: IpPermission[];
    
    SecurityGroupRuleDescriptions?: SecurityGroupRuleDescription[];
}
export declare namespace UpdateSecurityGroupRuleDescriptionsEgressRequest {
    
    const filterSensitiveLog: (obj: UpdateSecurityGroupRuleDescriptionsEgressRequest) => any;
}
export interface UpdateSecurityGroupRuleDescriptionsEgressResult {
    
    Return?: boolean;
}
export declare namespace UpdateSecurityGroupRuleDescriptionsEgressResult {
    
    const filterSensitiveLog: (obj: UpdateSecurityGroupRuleDescriptionsEgressResult) => any;
}
export interface UpdateSecurityGroupRuleDescriptionsIngressRequest {
    
    DryRun?: boolean;
    
    GroupId?: string;
    
    GroupName?: string;
    
    IpPermissions?: IpPermission[];
    
    SecurityGroupRuleDescriptions?: SecurityGroupRuleDescription[];
}
export declare namespace UpdateSecurityGroupRuleDescriptionsIngressRequest {
    
    const filterSensitiveLog: (obj: UpdateSecurityGroupRuleDescriptionsIngressRequest) => any;
}
export interface UpdateSecurityGroupRuleDescriptionsIngressResult {
    
    Return?: boolean;
}
export declare namespace UpdateSecurityGroupRuleDescriptionsIngressResult {
    
    const filterSensitiveLog: (obj: UpdateSecurityGroupRuleDescriptionsIngressResult) => any;
}
export interface WithdrawByoipCidrRequest {
    
    Cidr: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace WithdrawByoipCidrRequest {
    
    const filterSensitiveLog: (obj: WithdrawByoipCidrRequest) => any;
}
export interface WithdrawByoipCidrResult {
    
    ByoipCidr?: ByoipCidr;
}
export declare namespace WithdrawByoipCidrResult {
    
    const filterSensitiveLog: (obj: WithdrawByoipCidrResult) => any;
}
