import { _InstanceType, AddressAttribute, AllowedPrincipal, AssociationStatus, AttributeValue, AutoPlacement, CapacityReservationState, ClientConnectOptions, ConnectionLogOptions, CurrencyCodeValues, EndDateType, FleetExcessCapacityTerminationPolicy, FleetLaunchTemplateConfigRequest, HostRecovery, IamInstanceProfileAssociation, InstanceEventWindow, InstanceRequirementsRequest, Placement, ResourceType, SelfServicePortal, Subnet, SubnetAssociation, SubnetIpv6CidrBlockAssociation, Tag, TagSpecification, TargetCapacitySpecificationRequest, TargetCapacityUnitType, TargetConfigurationRequest, TransitGatewayAssociation, TransitGatewayAssociationState, TransitGatewayAttachmentResourceType, TransitGatewayAttachmentState, TransitGatewayMulticastDomainAssociations, TransitGatewayPeeringAttachment, TransitGatewayVpcAttachment, TrunkInterfaceAssociation, UnsuccessfulItem, Vpc, VpcCidrBlockAssociation, VpcIpv6CidrBlockAssociation, VpcPeeringConnection } from "./models_0";
import { CapacityReservationPreference, CapacityReservationTarget, ConnectionNotification, DiskImageFormat, DnsEntry, PlatformValues, ResponseLaunchTemplateData, ShutdownBehavior, State, SubnetCidrReservation, TrafficMirrorFilter, TrafficMirrorSession, TrafficMirrorTarget, TransitGateway, TransitGatewayConnect, TransitGatewayConnectPeer, TransitGatewayMulticastDomain, TransitGatewayPrefixListReference, TransitGatewayRouteTable, Volume, VolumeType, VpcEndpoint } from "./models_1";
import { ConversionTask, DnsNameState, ExportTaskS3Location, FastSnapshotRestoreStateCode, Filter, FpgaImageAttribute, FpgaImageAttributeName, PaymentOption, PermissionGroup, ProductCode, ServiceConfiguration, ServiceTypeDetail, VpnConnection, VpnGateway } from "./models_2";
import { ArchitectureType, ArchitectureValues, AttributeBooleanValue, BootModeValues, ImportImageLicenseConfigurationResponse, InstanceAttributeName, LaunchPermission, SnapshotDetail, SnapshotTaskDetail, VirtualizationType } from "./models_3";
export interface DescribeSubnetsResult {
    
    Subnets?: Subnet[];
    
    NextToken?: string;
}
export declare namespace DescribeSubnetsResult {
    
    const filterSensitiveLog: (obj: DescribeSubnetsResult) => any;
}
export interface DescribeTagsRequest {
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeTagsRequest {
    
    const filterSensitiveLog: (obj: DescribeTagsRequest) => any;
}

export interface TagDescription {
    
    Key?: string;
    
    ResourceId?: string;
    
    ResourceType?: ResourceType | string;
    
    Value?: string;
}
export declare namespace TagDescription {
    
    const filterSensitiveLog: (obj: TagDescription) => any;
}
export interface DescribeTagsResult {
    
    NextToken?: string;
    
    Tags?: TagDescription[];
}
export declare namespace DescribeTagsResult {
    
    const filterSensitiveLog: (obj: DescribeTagsResult) => any;
}
export interface DescribeTrafficMirrorFiltersRequest {
    
    TrafficMirrorFilterIds?: string[];
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeTrafficMirrorFiltersRequest {
    
    const filterSensitiveLog: (obj: DescribeTrafficMirrorFiltersRequest) => any;
}
export interface DescribeTrafficMirrorFiltersResult {
    
    TrafficMirrorFilters?: TrafficMirrorFilter[];
    
    NextToken?: string;
}
export declare namespace DescribeTrafficMirrorFiltersResult {
    
    const filterSensitiveLog: (obj: DescribeTrafficMirrorFiltersResult) => any;
}
export interface DescribeTrafficMirrorSessionsRequest {
    
    TrafficMirrorSessionIds?: string[];
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeTrafficMirrorSessionsRequest {
    
    const filterSensitiveLog: (obj: DescribeTrafficMirrorSessionsRequest) => any;
}
export interface DescribeTrafficMirrorSessionsResult {
    
    TrafficMirrorSessions?: TrafficMirrorSession[];
    
    NextToken?: string;
}
export declare namespace DescribeTrafficMirrorSessionsResult {
    
    const filterSensitiveLog: (obj: DescribeTrafficMirrorSessionsResult) => any;
}
export interface DescribeTrafficMirrorTargetsRequest {
    
    TrafficMirrorTargetIds?: string[];
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeTrafficMirrorTargetsRequest {
    
    const filterSensitiveLog: (obj: DescribeTrafficMirrorTargetsRequest) => any;
}
export interface DescribeTrafficMirrorTargetsResult {
    
    TrafficMirrorTargets?: TrafficMirrorTarget[];
    
    NextToken?: string;
}
export declare namespace DescribeTrafficMirrorTargetsResult {
    
    const filterSensitiveLog: (obj: DescribeTrafficMirrorTargetsResult) => any;
}
export interface DescribeTransitGatewayAttachmentsRequest {
    
    TransitGatewayAttachmentIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeTransitGatewayAttachmentsRequest {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayAttachmentsRequest) => any;
}

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

export interface TransitGatewayAttachment {
    
    TransitGatewayAttachmentId?: string;
    
    TransitGatewayId?: string;
    
    TransitGatewayOwnerId?: string;
    
    ResourceOwnerId?: string;
    
    ResourceType?: TransitGatewayAttachmentResourceType | string;
    
    ResourceId?: string;
    
    State?: TransitGatewayAttachmentState | string;
    
    Association?: TransitGatewayAttachmentAssociation;
    
    CreationTime?: Date;
    
    Tags?: Tag[];
}
export declare namespace TransitGatewayAttachment {
    
    const filterSensitiveLog: (obj: TransitGatewayAttachment) => any;
}
export interface DescribeTransitGatewayAttachmentsResult {
    
    TransitGatewayAttachments?: TransitGatewayAttachment[];
    
    NextToken?: string;
}
export declare namespace DescribeTransitGatewayAttachmentsResult {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayAttachmentsResult) => any;
}
export interface DescribeTransitGatewayConnectPeersRequest {
    
    TransitGatewayConnectPeerIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeTransitGatewayConnectPeersRequest {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayConnectPeersRequest) => any;
}
export interface DescribeTransitGatewayConnectPeersResult {
    
    TransitGatewayConnectPeers?: TransitGatewayConnectPeer[];
    
    NextToken?: string;
}
export declare namespace DescribeTransitGatewayConnectPeersResult {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayConnectPeersResult) => any;
}
export interface DescribeTransitGatewayConnectsRequest {
    
    TransitGatewayAttachmentIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeTransitGatewayConnectsRequest {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayConnectsRequest) => any;
}
export interface DescribeTransitGatewayConnectsResult {
    
    TransitGatewayConnects?: TransitGatewayConnect[];
    
    NextToken?: string;
}
export declare namespace DescribeTransitGatewayConnectsResult {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayConnectsResult) => any;
}
export interface DescribeTransitGatewayMulticastDomainsRequest {
    
    TransitGatewayMulticastDomainIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeTransitGatewayMulticastDomainsRequest {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayMulticastDomainsRequest) => any;
}
export interface DescribeTransitGatewayMulticastDomainsResult {
    
    TransitGatewayMulticastDomains?: TransitGatewayMulticastDomain[];
    
    NextToken?: string;
}
export declare namespace DescribeTransitGatewayMulticastDomainsResult {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayMulticastDomainsResult) => any;
}
export interface DescribeTransitGatewayPeeringAttachmentsRequest {
    
    TransitGatewayAttachmentIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeTransitGatewayPeeringAttachmentsRequest {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayPeeringAttachmentsRequest) => any;
}
export interface DescribeTransitGatewayPeeringAttachmentsResult {
    
    TransitGatewayPeeringAttachments?: TransitGatewayPeeringAttachment[];
    
    NextToken?: string;
}
export declare namespace DescribeTransitGatewayPeeringAttachmentsResult {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayPeeringAttachmentsResult) => any;
}
export interface DescribeTransitGatewayRouteTablesRequest {
    
    TransitGatewayRouteTableIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeTransitGatewayRouteTablesRequest {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayRouteTablesRequest) => any;
}
export interface DescribeTransitGatewayRouteTablesResult {
    
    TransitGatewayRouteTables?: TransitGatewayRouteTable[];
    
    NextToken?: string;
}
export declare namespace DescribeTransitGatewayRouteTablesResult {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayRouteTablesResult) => any;
}
export interface DescribeTransitGatewaysRequest {
    
    TransitGatewayIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeTransitGatewaysRequest {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewaysRequest) => any;
}
export interface DescribeTransitGatewaysResult {
    
    TransitGateways?: TransitGateway[];
    
    NextToken?: string;
}
export declare namespace DescribeTransitGatewaysResult {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewaysResult) => any;
}
export interface DescribeTransitGatewayVpcAttachmentsRequest {
    
    TransitGatewayAttachmentIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DescribeTransitGatewayVpcAttachmentsRequest {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayVpcAttachmentsRequest) => any;
}
export interface DescribeTransitGatewayVpcAttachmentsResult {
    
    TransitGatewayVpcAttachments?: TransitGatewayVpcAttachment[];
    
    NextToken?: string;
}
export declare namespace DescribeTransitGatewayVpcAttachmentsResult {
    
    const filterSensitiveLog: (obj: DescribeTransitGatewayVpcAttachmentsResult) => any;
}
export interface DescribeTrunkInterfaceAssociationsRequest {
    
    AssociationIds?: string[];
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeTrunkInterfaceAssociationsRequest {
    
    const filterSensitiveLog: (obj: DescribeTrunkInterfaceAssociationsRequest) => any;
}
export interface DescribeTrunkInterfaceAssociationsResult {
    
    InterfaceAssociations?: TrunkInterfaceAssociation[];
    
    NextToken?: string;
}
export declare namespace DescribeTrunkInterfaceAssociationsResult {
    
    const filterSensitiveLog: (obj: DescribeTrunkInterfaceAssociationsResult) => any;
}
export declare type VolumeAttributeName = "autoEnableIO" | "productCodes";
export interface DescribeVolumeAttributeRequest {
    
    Attribute: VolumeAttributeName | string | undefined;
    
    VolumeId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace DescribeVolumeAttributeRequest {
    
    const filterSensitiveLog: (obj: DescribeVolumeAttributeRequest) => any;
}
export interface DescribeVolumeAttributeResult {
    
    AutoEnableIO?: AttributeBooleanValue;
    
    ProductCodes?: ProductCode[];
    
    VolumeId?: string;
}
export declare namespace DescribeVolumeAttributeResult {
    
    const filterSensitiveLog: (obj: DescribeVolumeAttributeResult) => any;
}
export interface DescribeVolumesRequest {
    
    Filters?: Filter[];
    
    VolumeIds?: string[];
    
    DryRun?: boolean;
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeVolumesRequest {
    
    const filterSensitiveLog: (obj: DescribeVolumesRequest) => any;
}
export interface DescribeVolumesResult {
    
    Volumes?: Volume[];
    
    NextToken?: string;
}
export declare namespace DescribeVolumesResult {
    
    const filterSensitiveLog: (obj: DescribeVolumesResult) => any;
}
export interface DescribeVolumesModificationsRequest {
    
    DryRun?: boolean;
    
    VolumeIds?: string[];
    
    Filters?: Filter[];
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeVolumesModificationsRequest {
    
    const filterSensitiveLog: (obj: DescribeVolumesModificationsRequest) => any;
}
export declare type VolumeModificationState = "completed" | "failed" | "modifying" | "optimizing";

export interface VolumeModification {
    
    VolumeId?: string;
    
    ModificationState?: VolumeModificationState | string;
    
    StatusMessage?: string;
    
    TargetSize?: number;
    
    TargetIops?: number;
    
    TargetVolumeType?: VolumeType | string;
    
    TargetThroughput?: number;
    
    TargetMultiAttachEnabled?: boolean;
    
    OriginalSize?: number;
    
    OriginalIops?: number;
    
    OriginalVolumeType?: VolumeType | string;
    
    OriginalThroughput?: number;
    
    OriginalMultiAttachEnabled?: boolean;
    
    Progress?: number;
    
    StartTime?: Date;
    
    EndTime?: Date;
}
export declare namespace VolumeModification {
    
    const filterSensitiveLog: (obj: VolumeModification) => any;
}
export interface DescribeVolumesModificationsResult {
    
    VolumesModifications?: VolumeModification[];
    
    NextToken?: string;
}
export declare namespace DescribeVolumesModificationsResult {
    
    const filterSensitiveLog: (obj: DescribeVolumesModificationsResult) => any;
}
export interface DescribeVolumeStatusRequest {
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    VolumeIds?: string[];
    
    DryRun?: boolean;
}
export declare namespace DescribeVolumeStatusRequest {
    
    const filterSensitiveLog: (obj: DescribeVolumeStatusRequest) => any;
}

export interface VolumeStatusAction {
    
    Code?: string;
    
    Description?: string;
    
    EventId?: string;
    
    EventType?: string;
}
export declare namespace VolumeStatusAction {
    
    const filterSensitiveLog: (obj: VolumeStatusAction) => any;
}

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

export interface VolumeStatusEvent {
    
    Description?: string;
    
    EventId?: string;
    
    EventType?: string;
    
    NotAfter?: Date;
    
    NotBefore?: Date;
    
    InstanceId?: string;
}
export declare namespace VolumeStatusEvent {
    
    const filterSensitiveLog: (obj: VolumeStatusEvent) => any;
}
export declare type VolumeStatusName = "io-enabled" | "io-performance";

export interface VolumeStatusDetails {
    
    Name?: VolumeStatusName | string;
    
    Status?: string;
}
export declare namespace VolumeStatusDetails {
    
    const filterSensitiveLog: (obj: VolumeStatusDetails) => any;
}
export declare type VolumeStatusInfoStatus = "impaired" | "insufficient-data" | "ok";

export interface VolumeStatusInfo {
    
    Details?: VolumeStatusDetails[];
    
    Status?: VolumeStatusInfoStatus | string;
}
export declare namespace VolumeStatusInfo {
    
    const filterSensitiveLog: (obj: VolumeStatusInfo) => any;
}

export interface VolumeStatusItem {
    
    Actions?: VolumeStatusAction[];
    
    AvailabilityZone?: string;
    
    OutpostArn?: string;
    
    Events?: VolumeStatusEvent[];
    
    VolumeId?: string;
    
    VolumeStatus?: VolumeStatusInfo;
    
    AttachmentStatuses?: VolumeStatusAttachmentStatus[];
}
export declare namespace VolumeStatusItem {
    
    const filterSensitiveLog: (obj: VolumeStatusItem) => any;
}
export interface DescribeVolumeStatusResult {
    
    NextToken?: string;
    
    VolumeStatuses?: VolumeStatusItem[];
}
export declare namespace DescribeVolumeStatusResult {
    
    const filterSensitiveLog: (obj: DescribeVolumeStatusResult) => any;
}
export declare type VpcAttributeName = "enableDnsHostnames" | "enableDnsSupport";
export interface DescribeVpcAttributeRequest {
    
    Attribute: VpcAttributeName | string | undefined;
    
    VpcId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace DescribeVpcAttributeRequest {
    
    const filterSensitiveLog: (obj: DescribeVpcAttributeRequest) => any;
}
export interface DescribeVpcAttributeResult {
    
    VpcId?: string;
    
    EnableDnsHostnames?: AttributeBooleanValue;
    
    EnableDnsSupport?: AttributeBooleanValue;
}
export declare namespace DescribeVpcAttributeResult {
    
    const filterSensitiveLog: (obj: DescribeVpcAttributeResult) => any;
}
export interface DescribeVpcClassicLinkRequest {
    
    Filters?: Filter[];
    
    DryRun?: boolean;
    
    VpcIds?: string[];
}
export declare namespace DescribeVpcClassicLinkRequest {
    
    const filterSensitiveLog: (obj: DescribeVpcClassicLinkRequest) => any;
}

export interface VpcClassicLink {
    
    ClassicLinkEnabled?: boolean;
    
    Tags?: Tag[];
    
    VpcId?: string;
}
export declare namespace VpcClassicLink {
    
    const filterSensitiveLog: (obj: VpcClassicLink) => any;
}
export interface DescribeVpcClassicLinkResult {
    
    Vpcs?: VpcClassicLink[];
}
export declare namespace DescribeVpcClassicLinkResult {
    
    const filterSensitiveLog: (obj: DescribeVpcClassicLinkResult) => any;
}
export interface DescribeVpcClassicLinkDnsSupportRequest {
    
    MaxResults?: number;
    
    NextToken?: string;
    
    VpcIds?: string[];
}
export declare namespace DescribeVpcClassicLinkDnsSupportRequest {
    
    const filterSensitiveLog: (obj: DescribeVpcClassicLinkDnsSupportRequest) => any;
}

export interface ClassicLinkDnsSupport {
    
    ClassicLinkDnsSupported?: boolean;
    
    VpcId?: string;
}
export declare namespace ClassicLinkDnsSupport {
    
    const filterSensitiveLog: (obj: ClassicLinkDnsSupport) => any;
}
export interface DescribeVpcClassicLinkDnsSupportResult {
    
    NextToken?: string;
    
    Vpcs?: ClassicLinkDnsSupport[];
}
export declare namespace DescribeVpcClassicLinkDnsSupportResult {
    
    const filterSensitiveLog: (obj: DescribeVpcClassicLinkDnsSupportResult) => any;
}
export interface DescribeVpcEndpointConnectionNotificationsRequest {
    
    DryRun?: boolean;
    
    ConnectionNotificationId?: string;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeVpcEndpointConnectionNotificationsRequest {
    
    const filterSensitiveLog: (obj: DescribeVpcEndpointConnectionNotificationsRequest) => any;
}
export interface DescribeVpcEndpointConnectionNotificationsResult {
    
    ConnectionNotificationSet?: ConnectionNotification[];
    
    NextToken?: string;
}
export declare namespace DescribeVpcEndpointConnectionNotificationsResult {
    
    const filterSensitiveLog: (obj: DescribeVpcEndpointConnectionNotificationsResult) => any;
}
export interface DescribeVpcEndpointConnectionsRequest {
    
    DryRun?: boolean;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeVpcEndpointConnectionsRequest {
    
    const filterSensitiveLog: (obj: DescribeVpcEndpointConnectionsRequest) => any;
}

export interface VpcEndpointConnection {
    
    ServiceId?: string;
    
    VpcEndpointId?: string;
    
    VpcEndpointOwner?: string;
    
    VpcEndpointState?: State | string;
    
    CreationTimestamp?: Date;
    
    DnsEntries?: DnsEntry[];
    
    NetworkLoadBalancerArns?: string[];
    
    GatewayLoadBalancerArns?: string[];
}
export declare namespace VpcEndpointConnection {
    
    const filterSensitiveLog: (obj: VpcEndpointConnection) => any;
}
export interface DescribeVpcEndpointConnectionsResult {
    
    VpcEndpointConnections?: VpcEndpointConnection[];
    
    NextToken?: string;
}
export declare namespace DescribeVpcEndpointConnectionsResult {
    
    const filterSensitiveLog: (obj: DescribeVpcEndpointConnectionsResult) => any;
}

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

export interface DescribeVpcEndpointsResult {
    
    VpcEndpoints?: VpcEndpoint[];
    
    NextToken?: string;
}
export declare namespace DescribeVpcEndpointsResult {
    
    const filterSensitiveLog: (obj: DescribeVpcEndpointsResult) => any;
}
export interface DescribeVpcEndpointServiceConfigurationsRequest {
    
    DryRun?: boolean;
    
    ServiceIds?: string[];
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeVpcEndpointServiceConfigurationsRequest {
    
    const filterSensitiveLog: (obj: DescribeVpcEndpointServiceConfigurationsRequest) => any;
}
export interface DescribeVpcEndpointServiceConfigurationsResult {
    
    ServiceConfigurations?: ServiceConfiguration[];
    
    NextToken?: string;
}
export declare namespace DescribeVpcEndpointServiceConfigurationsResult {
    
    const filterSensitiveLog: (obj: DescribeVpcEndpointServiceConfigurationsResult) => any;
}
export interface DescribeVpcEndpointServicePermissionsRequest {
    
    DryRun?: boolean;
    
    ServiceId: string | undefined;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace DescribeVpcEndpointServicePermissionsRequest {
    
    const filterSensitiveLog: (obj: DescribeVpcEndpointServicePermissionsRequest) => any;
}
export interface DescribeVpcEndpointServicePermissionsResult {
    
    AllowedPrincipals?: AllowedPrincipal[];
    
    NextToken?: string;
}
export declare namespace DescribeVpcEndpointServicePermissionsResult {
    
    const filterSensitiveLog: (obj: DescribeVpcEndpointServicePermissionsResult) => any;
}

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

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

export interface ServiceDetail {
    
    ServiceName?: string;
    
    ServiceId?: string;
    
    ServiceType?: ServiceTypeDetail[];
    
    AvailabilityZones?: string[];
    
    Owner?: string;
    
    BaseEndpointDnsNames?: string[];
    
    PrivateDnsName?: string;
    
    PrivateDnsNames?: PrivateDnsDetails[];
    
    VpcEndpointPolicySupported?: boolean;
    
    AcceptanceRequired?: boolean;
    
    ManagesVpcEndpoints?: boolean;
    
    Tags?: Tag[];
    
    PrivateDnsNameVerificationState?: DnsNameState | string;
}
export declare namespace ServiceDetail {
    
    const filterSensitiveLog: (obj: ServiceDetail) => any;
}

export interface DescribeVpcEndpointServicesResult {
    
    ServiceNames?: string[];
    
    ServiceDetails?: ServiceDetail[];
    
    NextToken?: string;
}
export declare namespace DescribeVpcEndpointServicesResult {
    
    const filterSensitiveLog: (obj: DescribeVpcEndpointServicesResult) => any;
}
export interface DescribeVpcPeeringConnectionsRequest {
    
    Filters?: Filter[];
    
    DryRun?: boolean;
    
    VpcPeeringConnectionIds?: string[];
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeVpcPeeringConnectionsRequest {
    
    const filterSensitiveLog: (obj: DescribeVpcPeeringConnectionsRequest) => any;
}
export interface DescribeVpcPeeringConnectionsResult {
    
    VpcPeeringConnections?: VpcPeeringConnection[];
    
    NextToken?: string;
}
export declare namespace DescribeVpcPeeringConnectionsResult {
    
    const filterSensitiveLog: (obj: DescribeVpcPeeringConnectionsResult) => any;
}
export interface DescribeVpcsRequest {
    
    Filters?: Filter[];
    
    VpcIds?: string[];
    
    DryRun?: boolean;
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace DescribeVpcsRequest {
    
    const filterSensitiveLog: (obj: DescribeVpcsRequest) => any;
}
export interface DescribeVpcsResult {
    
    Vpcs?: Vpc[];
    
    NextToken?: string;
}
export declare namespace DescribeVpcsResult {
    
    const filterSensitiveLog: (obj: DescribeVpcsResult) => any;
}

export interface DescribeVpnConnectionsRequest {
    
    Filters?: Filter[];
    
    VpnConnectionIds?: string[];
    
    DryRun?: boolean;
}
export declare namespace DescribeVpnConnectionsRequest {
    
    const filterSensitiveLog: (obj: DescribeVpnConnectionsRequest) => any;
}

export interface DescribeVpnConnectionsResult {
    
    VpnConnections?: VpnConnection[];
}
export declare namespace DescribeVpnConnectionsResult {
    
    const filterSensitiveLog: (obj: DescribeVpnConnectionsResult) => any;
}

export interface DescribeVpnGatewaysRequest {
    
    Filters?: Filter[];
    
    VpnGatewayIds?: string[];
    
    DryRun?: boolean;
}
export declare namespace DescribeVpnGatewaysRequest {
    
    const filterSensitiveLog: (obj: DescribeVpnGatewaysRequest) => any;
}

export interface DescribeVpnGatewaysResult {
    
    VpnGateways?: VpnGateway[];
}
export declare namespace DescribeVpnGatewaysResult {
    
    const filterSensitiveLog: (obj: DescribeVpnGatewaysResult) => any;
}
export interface DetachClassicLinkVpcRequest {
    
    DryRun?: boolean;
    
    InstanceId: string | undefined;
    
    VpcId: string | undefined;
}
export declare namespace DetachClassicLinkVpcRequest {
    
    const filterSensitiveLog: (obj: DetachClassicLinkVpcRequest) => any;
}
export interface DetachClassicLinkVpcResult {
    
    Return?: boolean;
}
export declare namespace DetachClassicLinkVpcResult {
    
    const filterSensitiveLog: (obj: DetachClassicLinkVpcResult) => any;
}
export interface DetachInternetGatewayRequest {
    
    DryRun?: boolean;
    
    InternetGatewayId: string | undefined;
    
    VpcId: string | undefined;
}
export declare namespace DetachInternetGatewayRequest {
    
    const filterSensitiveLog: (obj: DetachInternetGatewayRequest) => any;
}

export interface DetachNetworkInterfaceRequest {
    
    AttachmentId: string | undefined;
    
    DryRun?: boolean;
    
    Force?: boolean;
}
export declare namespace DetachNetworkInterfaceRequest {
    
    const filterSensitiveLog: (obj: DetachNetworkInterfaceRequest) => any;
}
export interface DetachVolumeRequest {
    
    Device?: string;
    
    Force?: boolean;
    
    InstanceId?: string;
    
    VolumeId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace DetachVolumeRequest {
    
    const filterSensitiveLog: (obj: DetachVolumeRequest) => any;
}

export interface DetachVpnGatewayRequest {
    
    VpcId: string | undefined;
    
    VpnGatewayId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace DetachVpnGatewayRequest {
    
    const filterSensitiveLog: (obj: DetachVpnGatewayRequest) => any;
}
export interface DisableEbsEncryptionByDefaultRequest {
    
    DryRun?: boolean;
}
export declare namespace DisableEbsEncryptionByDefaultRequest {
    
    const filterSensitiveLog: (obj: DisableEbsEncryptionByDefaultRequest) => any;
}
export interface DisableEbsEncryptionByDefaultResult {
    
    EbsEncryptionByDefault?: boolean;
}
export declare namespace DisableEbsEncryptionByDefaultResult {
    
    const filterSensitiveLog: (obj: DisableEbsEncryptionByDefaultResult) => any;
}
export interface DisableFastSnapshotRestoresRequest {
    
    AvailabilityZones: string[] | undefined;
    
    SourceSnapshotIds: string[] | undefined;
    
    DryRun?: boolean;
}
export declare namespace DisableFastSnapshotRestoresRequest {
    
    const filterSensitiveLog: (obj: DisableFastSnapshotRestoresRequest) => any;
}

export interface DisableFastSnapshotRestoreSuccessItem {
    
    SnapshotId?: string;
    
    AvailabilityZone?: string;
    
    State?: FastSnapshotRestoreStateCode | string;
    
    StateTransitionReason?: string;
    
    OwnerId?: string;
    
    OwnerAlias?: string;
    
    EnablingTime?: Date;
    
    OptimizingTime?: Date;
    
    EnabledTime?: Date;
    
    DisablingTime?: Date;
    
    DisabledTime?: Date;
}
export declare namespace DisableFastSnapshotRestoreSuccessItem {
    
    const filterSensitiveLog: (obj: DisableFastSnapshotRestoreSuccessItem) => any;
}

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

export interface DisableFastSnapshotRestoreStateErrorItem {
    
    AvailabilityZone?: string;
    
    Error?: DisableFastSnapshotRestoreStateError;
}
export declare namespace DisableFastSnapshotRestoreStateErrorItem {
    
    const filterSensitiveLog: (obj: DisableFastSnapshotRestoreStateErrorItem) => any;
}

export interface DisableFastSnapshotRestoreErrorItem {
    
    SnapshotId?: string;
    
    FastSnapshotRestoreStateErrors?: DisableFastSnapshotRestoreStateErrorItem[];
}
export declare namespace DisableFastSnapshotRestoreErrorItem {
    
    const filterSensitiveLog: (obj: DisableFastSnapshotRestoreErrorItem) => any;
}
export interface DisableFastSnapshotRestoresResult {
    
    Successful?: DisableFastSnapshotRestoreSuccessItem[];
    
    Unsuccessful?: DisableFastSnapshotRestoreErrorItem[];
}
export declare namespace DisableFastSnapshotRestoresResult {
    
    const filterSensitiveLog: (obj: DisableFastSnapshotRestoresResult) => any;
}
export interface DisableImageDeprecationRequest {
    
    ImageId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace DisableImageDeprecationRequest {
    
    const filterSensitiveLog: (obj: DisableImageDeprecationRequest) => any;
}
export interface DisableImageDeprecationResult {
    
    Return?: boolean;
}
export declare namespace DisableImageDeprecationResult {
    
    const filterSensitiveLog: (obj: DisableImageDeprecationResult) => any;
}
export interface DisableSerialConsoleAccessRequest {
    
    DryRun?: boolean;
}
export declare namespace DisableSerialConsoleAccessRequest {
    
    const filterSensitiveLog: (obj: DisableSerialConsoleAccessRequest) => any;
}
export interface DisableSerialConsoleAccessResult {
    
    SerialConsoleAccessEnabled?: boolean;
}
export declare namespace DisableSerialConsoleAccessResult {
    
    const filterSensitiveLog: (obj: DisableSerialConsoleAccessResult) => any;
}
export interface DisableTransitGatewayRouteTablePropagationRequest {
    
    TransitGatewayRouteTableId: string | undefined;
    
    TransitGatewayAttachmentId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace DisableTransitGatewayRouteTablePropagationRequest {
    
    const filterSensitiveLog: (obj: DisableTransitGatewayRouteTablePropagationRequest) => any;
}
export declare type TransitGatewayPropagationState = "disabled" | "disabling" | "enabled" | "enabling";

export interface TransitGatewayPropagation {
    
    TransitGatewayAttachmentId?: string;
    
    ResourceId?: string;
    
    ResourceType?: TransitGatewayAttachmentResourceType | string;
    
    TransitGatewayRouteTableId?: string;
    
    State?: TransitGatewayPropagationState | string;
}
export declare namespace TransitGatewayPropagation {
    
    const filterSensitiveLog: (obj: TransitGatewayPropagation) => any;
}
export interface DisableTransitGatewayRouteTablePropagationResult {
    
    Propagation?: TransitGatewayPropagation;
}
export declare namespace DisableTransitGatewayRouteTablePropagationResult {
    
    const filterSensitiveLog: (obj: DisableTransitGatewayRouteTablePropagationResult) => any;
}

export interface DisableVgwRoutePropagationRequest {
    
    GatewayId: string | undefined;
    
    RouteTableId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace DisableVgwRoutePropagationRequest {
    
    const filterSensitiveLog: (obj: DisableVgwRoutePropagationRequest) => any;
}
export interface DisableVpcClassicLinkRequest {
    
    DryRun?: boolean;
    
    VpcId: string | undefined;
}
export declare namespace DisableVpcClassicLinkRequest {
    
    const filterSensitiveLog: (obj: DisableVpcClassicLinkRequest) => any;
}
export interface DisableVpcClassicLinkResult {
    
    Return?: boolean;
}
export declare namespace DisableVpcClassicLinkResult {
    
    const filterSensitiveLog: (obj: DisableVpcClassicLinkResult) => any;
}
export interface DisableVpcClassicLinkDnsSupportRequest {
    
    VpcId?: string;
}
export declare namespace DisableVpcClassicLinkDnsSupportRequest {
    
    const filterSensitiveLog: (obj: DisableVpcClassicLinkDnsSupportRequest) => any;
}
export interface DisableVpcClassicLinkDnsSupportResult {
    
    Return?: boolean;
}
export declare namespace DisableVpcClassicLinkDnsSupportResult {
    
    const filterSensitiveLog: (obj: DisableVpcClassicLinkDnsSupportResult) => any;
}
export interface DisassociateAddressRequest {
    
    AssociationId?: string;
    
    PublicIp?: string;
    
    DryRun?: boolean;
}
export declare namespace DisassociateAddressRequest {
    
    const filterSensitiveLog: (obj: DisassociateAddressRequest) => any;
}
export interface DisassociateClientVpnTargetNetworkRequest {
    
    ClientVpnEndpointId: string | undefined;
    
    AssociationId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace DisassociateClientVpnTargetNetworkRequest {
    
    const filterSensitiveLog: (obj: DisassociateClientVpnTargetNetworkRequest) => any;
}
export interface DisassociateClientVpnTargetNetworkResult {
    
    AssociationId?: string;
    
    Status?: AssociationStatus;
}
export declare namespace DisassociateClientVpnTargetNetworkResult {
    
    const filterSensitiveLog: (obj: DisassociateClientVpnTargetNetworkResult) => any;
}
export interface DisassociateEnclaveCertificateIamRoleRequest {
    
    CertificateArn?: string;
    
    RoleArn?: string;
    
    DryRun?: boolean;
}
export declare namespace DisassociateEnclaveCertificateIamRoleRequest {
    
    const filterSensitiveLog: (obj: DisassociateEnclaveCertificateIamRoleRequest) => any;
}
export interface DisassociateEnclaveCertificateIamRoleResult {
    
    Return?: boolean;
}
export declare namespace DisassociateEnclaveCertificateIamRoleResult {
    
    const filterSensitiveLog: (obj: DisassociateEnclaveCertificateIamRoleResult) => any;
}
export interface DisassociateIamInstanceProfileRequest {
    
    AssociationId: string | undefined;
}
export declare namespace DisassociateIamInstanceProfileRequest {
    
    const filterSensitiveLog: (obj: DisassociateIamInstanceProfileRequest) => any;
}
export interface DisassociateIamInstanceProfileResult {
    
    IamInstanceProfileAssociation?: IamInstanceProfileAssociation;
}
export declare namespace DisassociateIamInstanceProfileResult {
    
    const filterSensitiveLog: (obj: DisassociateIamInstanceProfileResult) => any;
}

export interface InstanceEventWindowDisassociationRequest {
    
    InstanceIds?: string[];
    
    InstanceTags?: Tag[];
    
    DedicatedHostIds?: string[];
}
export declare namespace InstanceEventWindowDisassociationRequest {
    
    const filterSensitiveLog: (obj: InstanceEventWindowDisassociationRequest) => any;
}
export interface DisassociateInstanceEventWindowRequest {
    
    DryRun?: boolean;
    
    InstanceEventWindowId: string | undefined;
    
    AssociationTarget: InstanceEventWindowDisassociationRequest | undefined;
}
export declare namespace DisassociateInstanceEventWindowRequest {
    
    const filterSensitiveLog: (obj: DisassociateInstanceEventWindowRequest) => any;
}
export interface DisassociateInstanceEventWindowResult {
    
    InstanceEventWindow?: InstanceEventWindow;
}
export declare namespace DisassociateInstanceEventWindowResult {
    
    const filterSensitiveLog: (obj: DisassociateInstanceEventWindowResult) => any;
}
export interface DisassociateRouteTableRequest {
    
    AssociationId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace DisassociateRouteTableRequest {
    
    const filterSensitiveLog: (obj: DisassociateRouteTableRequest) => any;
}
export interface DisassociateSubnetCidrBlockRequest {
    
    AssociationId: string | undefined;
}
export declare namespace DisassociateSubnetCidrBlockRequest {
    
    const filterSensitiveLog: (obj: DisassociateSubnetCidrBlockRequest) => any;
}
export interface DisassociateSubnetCidrBlockResult {
    
    Ipv6CidrBlockAssociation?: SubnetIpv6CidrBlockAssociation;
    
    SubnetId?: string;
}
export declare namespace DisassociateSubnetCidrBlockResult {
    
    const filterSensitiveLog: (obj: DisassociateSubnetCidrBlockResult) => any;
}
export interface DisassociateTransitGatewayMulticastDomainRequest {
    
    TransitGatewayMulticastDomainId?: string;
    
    TransitGatewayAttachmentId?: string;
    
    SubnetIds?: string[];
    
    DryRun?: boolean;
}
export declare namespace DisassociateTransitGatewayMulticastDomainRequest {
    
    const filterSensitiveLog: (obj: DisassociateTransitGatewayMulticastDomainRequest) => any;
}
export interface DisassociateTransitGatewayMulticastDomainResult {
    
    Associations?: TransitGatewayMulticastDomainAssociations;
}
export declare namespace DisassociateTransitGatewayMulticastDomainResult {
    
    const filterSensitiveLog: (obj: DisassociateTransitGatewayMulticastDomainResult) => any;
}
export interface DisassociateTransitGatewayRouteTableRequest {
    
    TransitGatewayRouteTableId: string | undefined;
    
    TransitGatewayAttachmentId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace DisassociateTransitGatewayRouteTableRequest {
    
    const filterSensitiveLog: (obj: DisassociateTransitGatewayRouteTableRequest) => any;
}
export interface DisassociateTransitGatewayRouteTableResult {
    
    Association?: TransitGatewayAssociation;
}
export declare namespace DisassociateTransitGatewayRouteTableResult {
    
    const filterSensitiveLog: (obj: DisassociateTransitGatewayRouteTableResult) => any;
}
export interface DisassociateTrunkInterfaceRequest {
    
    AssociationId: string | undefined;
    
    ClientToken?: string;
    
    DryRun?: boolean;
}
export declare namespace DisassociateTrunkInterfaceRequest {
    
    const filterSensitiveLog: (obj: DisassociateTrunkInterfaceRequest) => any;
}
export interface DisassociateTrunkInterfaceResult {
    
    Return?: boolean;
    
    ClientToken?: string;
}
export declare namespace DisassociateTrunkInterfaceResult {
    
    const filterSensitiveLog: (obj: DisassociateTrunkInterfaceResult) => any;
}
export interface DisassociateVpcCidrBlockRequest {
    
    AssociationId: string | undefined;
}
export declare namespace DisassociateVpcCidrBlockRequest {
    
    const filterSensitiveLog: (obj: DisassociateVpcCidrBlockRequest) => any;
}
export interface DisassociateVpcCidrBlockResult {
    
    Ipv6CidrBlockAssociation?: VpcIpv6CidrBlockAssociation;
    
    CidrBlockAssociation?: VpcCidrBlockAssociation;
    
    VpcId?: string;
}
export declare namespace DisassociateVpcCidrBlockResult {
    
    const filterSensitiveLog: (obj: DisassociateVpcCidrBlockResult) => any;
}
export interface EnableEbsEncryptionByDefaultRequest {
    
    DryRun?: boolean;
}
export declare namespace EnableEbsEncryptionByDefaultRequest {
    
    const filterSensitiveLog: (obj: EnableEbsEncryptionByDefaultRequest) => any;
}
export interface EnableEbsEncryptionByDefaultResult {
    
    EbsEncryptionByDefault?: boolean;
}
export declare namespace EnableEbsEncryptionByDefaultResult {
    
    const filterSensitiveLog: (obj: EnableEbsEncryptionByDefaultResult) => any;
}
export interface EnableFastSnapshotRestoresRequest {
    
    AvailabilityZones: string[] | undefined;
    
    SourceSnapshotIds: string[] | undefined;
    
    DryRun?: boolean;
}
export declare namespace EnableFastSnapshotRestoresRequest {
    
    const filterSensitiveLog: (obj: EnableFastSnapshotRestoresRequest) => any;
}

export interface EnableFastSnapshotRestoreSuccessItem {
    
    SnapshotId?: string;
    
    AvailabilityZone?: string;
    
    State?: FastSnapshotRestoreStateCode | string;
    
    StateTransitionReason?: string;
    
    OwnerId?: string;
    
    OwnerAlias?: string;
    
    EnablingTime?: Date;
    
    OptimizingTime?: Date;
    
    EnabledTime?: Date;
    
    DisablingTime?: Date;
    
    DisabledTime?: Date;
}
export declare namespace EnableFastSnapshotRestoreSuccessItem {
    
    const filterSensitiveLog: (obj: EnableFastSnapshotRestoreSuccessItem) => any;
}

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

export interface EnableFastSnapshotRestoreStateErrorItem {
    
    AvailabilityZone?: string;
    
    Error?: EnableFastSnapshotRestoreStateError;
}
export declare namespace EnableFastSnapshotRestoreStateErrorItem {
    
    const filterSensitiveLog: (obj: EnableFastSnapshotRestoreStateErrorItem) => any;
}

export interface EnableFastSnapshotRestoreErrorItem {
    
    SnapshotId?: string;
    
    FastSnapshotRestoreStateErrors?: EnableFastSnapshotRestoreStateErrorItem[];
}
export declare namespace EnableFastSnapshotRestoreErrorItem {
    
    const filterSensitiveLog: (obj: EnableFastSnapshotRestoreErrorItem) => any;
}
export interface EnableFastSnapshotRestoresResult {
    
    Successful?: EnableFastSnapshotRestoreSuccessItem[];
    
    Unsuccessful?: EnableFastSnapshotRestoreErrorItem[];
}
export declare namespace EnableFastSnapshotRestoresResult {
    
    const filterSensitiveLog: (obj: EnableFastSnapshotRestoresResult) => any;
}
export interface EnableImageDeprecationRequest {
    
    ImageId: string | undefined;
    
    DeprecateAt: Date | undefined;
    
    DryRun?: boolean;
}
export declare namespace EnableImageDeprecationRequest {
    
    const filterSensitiveLog: (obj: EnableImageDeprecationRequest) => any;
}
export interface EnableImageDeprecationResult {
    
    Return?: boolean;
}
export declare namespace EnableImageDeprecationResult {
    
    const filterSensitiveLog: (obj: EnableImageDeprecationResult) => any;
}
export interface EnableSerialConsoleAccessRequest {
    
    DryRun?: boolean;
}
export declare namespace EnableSerialConsoleAccessRequest {
    
    const filterSensitiveLog: (obj: EnableSerialConsoleAccessRequest) => any;
}
export interface EnableSerialConsoleAccessResult {
    
    SerialConsoleAccessEnabled?: boolean;
}
export declare namespace EnableSerialConsoleAccessResult {
    
    const filterSensitiveLog: (obj: EnableSerialConsoleAccessResult) => any;
}
export interface EnableTransitGatewayRouteTablePropagationRequest {
    
    TransitGatewayRouteTableId: string | undefined;
    
    TransitGatewayAttachmentId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace EnableTransitGatewayRouteTablePropagationRequest {
    
    const filterSensitiveLog: (obj: EnableTransitGatewayRouteTablePropagationRequest) => any;
}
export interface EnableTransitGatewayRouteTablePropagationResult {
    
    Propagation?: TransitGatewayPropagation;
}
export declare namespace EnableTransitGatewayRouteTablePropagationResult {
    
    const filterSensitiveLog: (obj: EnableTransitGatewayRouteTablePropagationResult) => any;
}

export interface EnableVgwRoutePropagationRequest {
    
    GatewayId: string | undefined;
    
    RouteTableId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace EnableVgwRoutePropagationRequest {
    
    const filterSensitiveLog: (obj: EnableVgwRoutePropagationRequest) => any;
}
export interface EnableVolumeIORequest {
    
    DryRun?: boolean;
    
    VolumeId: string | undefined;
}
export declare namespace EnableVolumeIORequest {
    
    const filterSensitiveLog: (obj: EnableVolumeIORequest) => any;
}
export interface EnableVpcClassicLinkRequest {
    
    DryRun?: boolean;
    
    VpcId: string | undefined;
}
export declare namespace EnableVpcClassicLinkRequest {
    
    const filterSensitiveLog: (obj: EnableVpcClassicLinkRequest) => any;
}
export interface EnableVpcClassicLinkResult {
    
    Return?: boolean;
}
export declare namespace EnableVpcClassicLinkResult {
    
    const filterSensitiveLog: (obj: EnableVpcClassicLinkResult) => any;
}
export interface EnableVpcClassicLinkDnsSupportRequest {
    
    VpcId?: string;
}
export declare namespace EnableVpcClassicLinkDnsSupportRequest {
    
    const filterSensitiveLog: (obj: EnableVpcClassicLinkDnsSupportRequest) => any;
}
export interface EnableVpcClassicLinkDnsSupportResult {
    
    Return?: boolean;
}
export declare namespace EnableVpcClassicLinkDnsSupportResult {
    
    const filterSensitiveLog: (obj: EnableVpcClassicLinkDnsSupportResult) => any;
}
export interface ExportClientVpnClientCertificateRevocationListRequest {
    
    ClientVpnEndpointId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace ExportClientVpnClientCertificateRevocationListRequest {
    
    const filterSensitiveLog: (obj: ExportClientVpnClientCertificateRevocationListRequest) => any;
}
export declare type ClientCertificateRevocationListStatusCode = "active" | "pending";

export interface ClientCertificateRevocationListStatus {
    
    Code?: ClientCertificateRevocationListStatusCode | string;
    
    Message?: string;
}
export declare namespace ClientCertificateRevocationListStatus {
    
    const filterSensitiveLog: (obj: ClientCertificateRevocationListStatus) => any;
}
export interface ExportClientVpnClientCertificateRevocationListResult {
    
    CertificateRevocationList?: string;
    
    Status?: ClientCertificateRevocationListStatus;
}
export declare namespace ExportClientVpnClientCertificateRevocationListResult {
    
    const filterSensitiveLog: (obj: ExportClientVpnClientCertificateRevocationListResult) => any;
}
export interface ExportClientVpnClientConfigurationRequest {
    
    ClientVpnEndpointId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace ExportClientVpnClientConfigurationRequest {
    
    const filterSensitiveLog: (obj: ExportClientVpnClientConfigurationRequest) => any;
}
export interface ExportClientVpnClientConfigurationResult {
    
    ClientConfiguration?: string;
}
export declare namespace ExportClientVpnClientConfigurationResult {
    
    const filterSensitiveLog: (obj: ExportClientVpnClientConfigurationResult) => any;
}

export interface ExportTaskS3LocationRequest {
    
    S3Bucket: string | undefined;
    
    S3Prefix?: string;
}
export declare namespace ExportTaskS3LocationRequest {
    
    const filterSensitiveLog: (obj: ExportTaskS3LocationRequest) => any;
}
export interface ExportImageRequest {
    
    ClientToken?: string;
    
    Description?: string;
    
    DiskImageFormat: DiskImageFormat | string | undefined;
    
    DryRun?: boolean;
    
    ImageId: string | undefined;
    
    S3ExportLocation: ExportTaskS3LocationRequest | undefined;
    
    RoleName?: string;
    
    TagSpecifications?: TagSpecification[];
}
export declare namespace ExportImageRequest {
    
    const filterSensitiveLog: (obj: ExportImageRequest) => any;
}
export interface ExportImageResult {
    
    Description?: string;
    
    DiskImageFormat?: DiskImageFormat | string;
    
    ExportImageTaskId?: string;
    
    ImageId?: string;
    
    RoleName?: string;
    
    Progress?: string;
    
    S3ExportLocation?: ExportTaskS3Location;
    
    Status?: string;
    
    StatusMessage?: string;
    
    Tags?: Tag[];
}
export declare namespace ExportImageResult {
    
    const filterSensitiveLog: (obj: ExportImageResult) => any;
}
export interface ExportTransitGatewayRoutesRequest {
    
    TransitGatewayRouteTableId: string | undefined;
    
    Filters?: Filter[];
    
    S3Bucket: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace ExportTransitGatewayRoutesRequest {
    
    const filterSensitiveLog: (obj: ExportTransitGatewayRoutesRequest) => any;
}
export interface ExportTransitGatewayRoutesResult {
    
    S3Location?: string;
}
export declare namespace ExportTransitGatewayRoutesResult {
    
    const filterSensitiveLog: (obj: ExportTransitGatewayRoutesResult) => any;
}
export interface GetAssociatedEnclaveCertificateIamRolesRequest {
    
    CertificateArn?: string;
    
    DryRun?: boolean;
}
export declare namespace GetAssociatedEnclaveCertificateIamRolesRequest {
    
    const filterSensitiveLog: (obj: GetAssociatedEnclaveCertificateIamRolesRequest) => any;
}

export interface AssociatedRole {
    
    AssociatedRoleArn?: string;
    
    CertificateS3BucketName?: string;
    
    CertificateS3ObjectKey?: string;
    
    EncryptionKmsKeyId?: string;
}
export declare namespace AssociatedRole {
    
    const filterSensitiveLog: (obj: AssociatedRole) => any;
}
export interface GetAssociatedEnclaveCertificateIamRolesResult {
    
    AssociatedRoles?: AssociatedRole[];
}
export declare namespace GetAssociatedEnclaveCertificateIamRolesResult {
    
    const filterSensitiveLog: (obj: GetAssociatedEnclaveCertificateIamRolesResult) => any;
}
export interface GetAssociatedIpv6PoolCidrsRequest {
    
    PoolId: string | undefined;
    
    NextToken?: string;
    
    MaxResults?: number;
    
    DryRun?: boolean;
}
export declare namespace GetAssociatedIpv6PoolCidrsRequest {
    
    const filterSensitiveLog: (obj: GetAssociatedIpv6PoolCidrsRequest) => any;
}

export interface Ipv6CidrAssociation {
    
    Ipv6Cidr?: string;
    
    AssociatedResource?: string;
}
export declare namespace Ipv6CidrAssociation {
    
    const filterSensitiveLog: (obj: Ipv6CidrAssociation) => any;
}
export interface GetAssociatedIpv6PoolCidrsResult {
    
    Ipv6CidrAssociations?: Ipv6CidrAssociation[];
    
    NextToken?: string;
}
export declare namespace GetAssociatedIpv6PoolCidrsResult {
    
    const filterSensitiveLog: (obj: GetAssociatedIpv6PoolCidrsResult) => any;
}
export interface GetCapacityReservationUsageRequest {
    
    CapacityReservationId: string | undefined;
    
    NextToken?: string;
    
    MaxResults?: number;
    
    DryRun?: boolean;
}
export declare namespace GetCapacityReservationUsageRequest {
    
    const filterSensitiveLog: (obj: GetCapacityReservationUsageRequest) => any;
}

export interface InstanceUsage {
    
    AccountId?: string;
    
    UsedInstanceCount?: number;
}
export declare namespace InstanceUsage {
    
    const filterSensitiveLog: (obj: InstanceUsage) => any;
}
export interface GetCapacityReservationUsageResult {
    
    NextToken?: string;
    
    CapacityReservationId?: string;
    
    InstanceType?: string;
    
    TotalInstanceCount?: number;
    
    AvailableInstanceCount?: number;
    
    State?: CapacityReservationState | string;
    
    InstanceUsages?: InstanceUsage[];
}
export declare namespace GetCapacityReservationUsageResult {
    
    const filterSensitiveLog: (obj: GetCapacityReservationUsageResult) => any;
}
export interface GetCoipPoolUsageRequest {
    
    PoolId: string | undefined;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace GetCoipPoolUsageRequest {
    
    const filterSensitiveLog: (obj: GetCoipPoolUsageRequest) => any;
}

export interface CoipAddressUsage {
    
    AllocationId?: string;
    
    AwsAccountId?: string;
    
    AwsService?: string;
    
    CoIp?: string;
}
export declare namespace CoipAddressUsage {
    
    const filterSensitiveLog: (obj: CoipAddressUsage) => any;
}
export interface GetCoipPoolUsageResult {
    
    CoipPoolId?: string;
    
    CoipAddressUsages?: CoipAddressUsage[];
    
    LocalGatewayRouteTableId?: string;
}
export declare namespace GetCoipPoolUsageResult {
    
    const filterSensitiveLog: (obj: GetCoipPoolUsageResult) => any;
}
export interface GetConsoleOutputRequest {
    
    InstanceId: string | undefined;
    
    DryRun?: boolean;
    
    Latest?: boolean;
}
export declare namespace GetConsoleOutputRequest {
    
    const filterSensitiveLog: (obj: GetConsoleOutputRequest) => any;
}
export interface GetConsoleOutputResult {
    
    InstanceId?: string;
    
    Output?: string;
    
    Timestamp?: Date;
}
export declare namespace GetConsoleOutputResult {
    
    const filterSensitiveLog: (obj: GetConsoleOutputResult) => any;
}
export interface GetConsoleScreenshotRequest {
    
    DryRun?: boolean;
    
    InstanceId: string | undefined;
    
    WakeUp?: boolean;
}
export declare namespace GetConsoleScreenshotRequest {
    
    const filterSensitiveLog: (obj: GetConsoleScreenshotRequest) => any;
}
export interface GetConsoleScreenshotResult {
    
    ImageData?: string;
    
    InstanceId?: string;
}
export declare namespace GetConsoleScreenshotResult {
    
    const filterSensitiveLog: (obj: GetConsoleScreenshotResult) => any;
}
export declare type UnlimitedSupportedInstanceFamily = "t2" | "t3" | "t3a" | "t4g";
export interface GetDefaultCreditSpecificationRequest {
    
    DryRun?: boolean;
    
    InstanceFamily: UnlimitedSupportedInstanceFamily | string | undefined;
}
export declare namespace GetDefaultCreditSpecificationRequest {
    
    const filterSensitiveLog: (obj: GetDefaultCreditSpecificationRequest) => any;
}

export interface InstanceFamilyCreditSpecification {
    
    InstanceFamily?: UnlimitedSupportedInstanceFamily | string;
    
    CpuCredits?: string;
}
export declare namespace InstanceFamilyCreditSpecification {
    
    const filterSensitiveLog: (obj: InstanceFamilyCreditSpecification) => any;
}
export interface GetDefaultCreditSpecificationResult {
    
    InstanceFamilyCreditSpecification?: InstanceFamilyCreditSpecification;
}
export declare namespace GetDefaultCreditSpecificationResult {
    
    const filterSensitiveLog: (obj: GetDefaultCreditSpecificationResult) => any;
}
export interface GetEbsDefaultKmsKeyIdRequest {
    
    DryRun?: boolean;
}
export declare namespace GetEbsDefaultKmsKeyIdRequest {
    
    const filterSensitiveLog: (obj: GetEbsDefaultKmsKeyIdRequest) => any;
}
export interface GetEbsDefaultKmsKeyIdResult {
    
    KmsKeyId?: string;
}
export declare namespace GetEbsDefaultKmsKeyIdResult {
    
    const filterSensitiveLog: (obj: GetEbsDefaultKmsKeyIdResult) => any;
}
export interface GetEbsEncryptionByDefaultRequest {
    
    DryRun?: boolean;
}
export declare namespace GetEbsEncryptionByDefaultRequest {
    
    const filterSensitiveLog: (obj: GetEbsEncryptionByDefaultRequest) => any;
}
export interface GetEbsEncryptionByDefaultResult {
    
    EbsEncryptionByDefault?: boolean;
}
export declare namespace GetEbsEncryptionByDefaultResult {
    
    const filterSensitiveLog: (obj: GetEbsEncryptionByDefaultResult) => any;
}
export declare enum PartitionLoadFrequency {
    DAILY = "daily",
    MONTHLY = "monthly",
    NONE = "none",
    WEEKLY = "weekly"
}

export interface AthenaIntegration {
    
    IntegrationResultS3DestinationArn: string | undefined;
    
    PartitionLoadFrequency: PartitionLoadFrequency | string | undefined;
    
    PartitionStartDate?: Date;
    
    PartitionEndDate?: Date;
}
export declare namespace AthenaIntegration {
    
    const filterSensitiveLog: (obj: AthenaIntegration) => any;
}

export interface IntegrateServices {
    
    AthenaIntegrations?: AthenaIntegration[];
}
export declare namespace IntegrateServices {
    
    const filterSensitiveLog: (obj: IntegrateServices) => any;
}
export interface GetFlowLogsIntegrationTemplateRequest {
    
    DryRun?: boolean;
    
    FlowLogId: string | undefined;
    
    ConfigDeliveryS3DestinationArn: string | undefined;
    
    IntegrateServices: IntegrateServices | undefined;
}
export declare namespace GetFlowLogsIntegrationTemplateRequest {
    
    const filterSensitiveLog: (obj: GetFlowLogsIntegrationTemplateRequest) => any;
}
export interface GetFlowLogsIntegrationTemplateResult {
    
    Result?: string;
}
export declare namespace GetFlowLogsIntegrationTemplateResult {
    
    const filterSensitiveLog: (obj: GetFlowLogsIntegrationTemplateResult) => any;
}
export interface GetGroupsForCapacityReservationRequest {
    
    CapacityReservationId: string | undefined;
    
    NextToken?: string;
    
    MaxResults?: number;
    
    DryRun?: boolean;
}
export declare namespace GetGroupsForCapacityReservationRequest {
    
    const filterSensitiveLog: (obj: GetGroupsForCapacityReservationRequest) => any;
}

export interface CapacityReservationGroup {
    
    GroupArn?: string;
    
    OwnerId?: string;
}
export declare namespace CapacityReservationGroup {
    
    const filterSensitiveLog: (obj: CapacityReservationGroup) => any;
}
export interface GetGroupsForCapacityReservationResult {
    
    NextToken?: string;
    
    CapacityReservationGroups?: CapacityReservationGroup[];
}
export declare namespace GetGroupsForCapacityReservationResult {
    
    const filterSensitiveLog: (obj: GetGroupsForCapacityReservationResult) => any;
}
export interface GetHostReservationPurchasePreviewRequest {
    
    HostIdSet: string[] | undefined;
    
    OfferingId: string | undefined;
}
export declare namespace GetHostReservationPurchasePreviewRequest {
    
    const filterSensitiveLog: (obj: GetHostReservationPurchasePreviewRequest) => any;
}

export interface Purchase {
    
    CurrencyCode?: CurrencyCodeValues | string;
    
    Duration?: number;
    
    HostIdSet?: string[];
    
    HostReservationId?: string;
    
    HourlyPrice?: string;
    
    InstanceFamily?: string;
    
    PaymentOption?: PaymentOption | string;
    
    UpfrontPrice?: string;
}
export declare namespace Purchase {
    
    const filterSensitiveLog: (obj: Purchase) => any;
}
export interface GetHostReservationPurchasePreviewResult {
    
    CurrencyCode?: CurrencyCodeValues | string;
    
    Purchase?: Purchase[];
    
    TotalHourlyPrice?: string;
    
    TotalUpfrontPrice?: string;
}
export declare namespace GetHostReservationPurchasePreviewResult {
    
    const filterSensitiveLog: (obj: GetHostReservationPurchasePreviewResult) => any;
}
export interface GetInstanceTypesFromInstanceRequirementsRequest {
    
    DryRun?: boolean;
    
    ArchitectureTypes: (ArchitectureType | string)[] | undefined;
    
    VirtualizationTypes: (VirtualizationType | string)[] | undefined;
    
    InstanceRequirements: InstanceRequirementsRequest | undefined;
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace GetInstanceTypesFromInstanceRequirementsRequest {
    
    const filterSensitiveLog: (obj: GetInstanceTypesFromInstanceRequirementsRequest) => any;
}

export interface InstanceTypeInfoFromInstanceRequirements {
    
    InstanceType?: string;
}
export declare namespace InstanceTypeInfoFromInstanceRequirements {
    
    const filterSensitiveLog: (obj: InstanceTypeInfoFromInstanceRequirements) => any;
}
export interface GetInstanceTypesFromInstanceRequirementsResult {
    
    InstanceTypes?: InstanceTypeInfoFromInstanceRequirements[];
    
    NextToken?: string;
}
export declare namespace GetInstanceTypesFromInstanceRequirementsResult {
    
    const filterSensitiveLog: (obj: GetInstanceTypesFromInstanceRequirementsResult) => any;
}
export interface GetLaunchTemplateDataRequest {
    
    DryRun?: boolean;
    
    InstanceId: string | undefined;
}
export declare namespace GetLaunchTemplateDataRequest {
    
    const filterSensitiveLog: (obj: GetLaunchTemplateDataRequest) => any;
}
export interface GetLaunchTemplateDataResult {
    
    LaunchTemplateData?: ResponseLaunchTemplateData;
}
export declare namespace GetLaunchTemplateDataResult {
    
    const filterSensitiveLog: (obj: GetLaunchTemplateDataResult) => any;
}
export interface GetManagedPrefixListAssociationsRequest {
    
    DryRun?: boolean;
    
    PrefixListId: string | undefined;
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace GetManagedPrefixListAssociationsRequest {
    
    const filterSensitiveLog: (obj: GetManagedPrefixListAssociationsRequest) => any;
}

export interface PrefixListAssociation {
    
    ResourceId?: string;
    
    ResourceOwner?: string;
}
export declare namespace PrefixListAssociation {
    
    const filterSensitiveLog: (obj: PrefixListAssociation) => any;
}
export interface GetManagedPrefixListAssociationsResult {
    
    PrefixListAssociations?: PrefixListAssociation[];
    
    NextToken?: string;
}
export declare namespace GetManagedPrefixListAssociationsResult {
    
    const filterSensitiveLog: (obj: GetManagedPrefixListAssociationsResult) => any;
}
export interface GetManagedPrefixListEntriesRequest {
    
    DryRun?: boolean;
    
    PrefixListId: string | undefined;
    
    TargetVersion?: number;
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace GetManagedPrefixListEntriesRequest {
    
    const filterSensitiveLog: (obj: GetManagedPrefixListEntriesRequest) => any;
}

export interface PrefixListEntry {
    
    Cidr?: string;
    
    Description?: string;
}
export declare namespace PrefixListEntry {
    
    const filterSensitiveLog: (obj: PrefixListEntry) => any;
}
export interface GetManagedPrefixListEntriesResult {
    
    Entries?: PrefixListEntry[];
    
    NextToken?: string;
}
export declare namespace GetManagedPrefixListEntriesResult {
    
    const filterSensitiveLog: (obj: GetManagedPrefixListEntriesResult) => any;
}
export interface GetPasswordDataRequest {
    
    InstanceId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace GetPasswordDataRequest {
    
    const filterSensitiveLog: (obj: GetPasswordDataRequest) => any;
}
export interface GetPasswordDataResult {
    
    InstanceId?: string;
    
    PasswordData?: string;
    
    Timestamp?: Date;
}
export declare namespace GetPasswordDataResult {
    
    const filterSensitiveLog: (obj: GetPasswordDataResult) => any;
}

export interface GetReservedInstancesExchangeQuoteRequest {
    
    DryRun?: boolean;
    
    ReservedInstanceIds: string[] | undefined;
    
    TargetConfigurations?: TargetConfigurationRequest[];
}
export declare namespace GetReservedInstancesExchangeQuoteRequest {
    
    const filterSensitiveLog: (obj: GetReservedInstancesExchangeQuoteRequest) => any;
}

export interface ReservationValue {
    
    HourlyPrice?: string;
    
    RemainingTotalValue?: string;
    
    RemainingUpfrontValue?: string;
}
export declare namespace ReservationValue {
    
    const filterSensitiveLog: (obj: ReservationValue) => any;
}

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

export interface TargetConfiguration {
    
    InstanceCount?: number;
    
    OfferingId?: string;
}
export declare namespace TargetConfiguration {
    
    const filterSensitiveLog: (obj: TargetConfiguration) => any;
}

export interface TargetReservationValue {
    
    ReservationValue?: ReservationValue;
    
    TargetConfiguration?: TargetConfiguration;
}
export declare namespace TargetReservationValue {
    
    const filterSensitiveLog: (obj: TargetReservationValue) => any;
}

export interface GetReservedInstancesExchangeQuoteResult {
    
    CurrencyCode?: string;
    
    IsValidExchange?: boolean;
    
    OutputReservedInstancesWillExpireAt?: Date;
    
    PaymentDue?: string;
    
    ReservedInstanceValueRollup?: ReservationValue;
    
    ReservedInstanceValueSet?: ReservedInstanceReservationValue[];
    
    TargetConfigurationValueRollup?: ReservationValue;
    
    TargetConfigurationValueSet?: TargetReservationValue[];
    
    ValidationFailureReason?: string;
}
export declare namespace GetReservedInstancesExchangeQuoteResult {
    
    const filterSensitiveLog: (obj: GetReservedInstancesExchangeQuoteResult) => any;
}
export interface GetSerialConsoleAccessStatusRequest {
    
    DryRun?: boolean;
}
export declare namespace GetSerialConsoleAccessStatusRequest {
    
    const filterSensitiveLog: (obj: GetSerialConsoleAccessStatusRequest) => any;
}
export interface GetSerialConsoleAccessStatusResult {
    
    SerialConsoleAccessEnabled?: boolean;
}
export declare namespace GetSerialConsoleAccessStatusResult {
    
    const filterSensitiveLog: (obj: GetSerialConsoleAccessStatusResult) => any;
}

export interface InstanceRequirementsWithMetadataRequest {
    
    ArchitectureTypes?: (ArchitectureType | string)[];
    
    VirtualizationTypes?: (VirtualizationType | string)[];
    
    InstanceRequirements?: InstanceRequirementsRequest;
}
export declare namespace InstanceRequirementsWithMetadataRequest {
    
    const filterSensitiveLog: (obj: InstanceRequirementsWithMetadataRequest) => any;
}
export interface GetSpotPlacementScoresRequest {
    
    InstanceTypes?: string[];
    
    TargetCapacity: number | undefined;
    
    TargetCapacityUnitType?: TargetCapacityUnitType | string;
    
    SingleAvailabilityZone?: boolean;
    
    RegionNames?: string[];
    
    InstanceRequirementsWithMetadata?: InstanceRequirementsWithMetadataRequest;
    
    DryRun?: boolean;
    
    MaxResults?: number;
    
    NextToken?: string;
}
export declare namespace GetSpotPlacementScoresRequest {
    
    const filterSensitiveLog: (obj: GetSpotPlacementScoresRequest) => any;
}

export interface SpotPlacementScore {
    
    Region?: string;
    
    AvailabilityZoneId?: string;
    
    Score?: number;
}
export declare namespace SpotPlacementScore {
    
    const filterSensitiveLog: (obj: SpotPlacementScore) => any;
}
export interface GetSpotPlacementScoresResult {
    
    SpotPlacementScores?: SpotPlacementScore[];
    
    NextToken?: string;
}
export declare namespace GetSpotPlacementScoresResult {
    
    const filterSensitiveLog: (obj: GetSpotPlacementScoresResult) => any;
}
export interface GetSubnetCidrReservationsRequest {
    
    Filters?: Filter[];
    
    SubnetId: string | undefined;
    
    DryRun?: boolean;
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare namespace GetSubnetCidrReservationsRequest {
    
    const filterSensitiveLog: (obj: GetSubnetCidrReservationsRequest) => any;
}
export interface GetSubnetCidrReservationsResult {
    
    SubnetIpv4CidrReservations?: SubnetCidrReservation[];
    
    SubnetIpv6CidrReservations?: SubnetCidrReservation[];
    
    NextToken?: string;
}
export declare namespace GetSubnetCidrReservationsResult {
    
    const filterSensitiveLog: (obj: GetSubnetCidrReservationsResult) => any;
}
export interface GetTransitGatewayAttachmentPropagationsRequest {
    
    TransitGatewayAttachmentId: string | undefined;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace GetTransitGatewayAttachmentPropagationsRequest {
    
    const filterSensitiveLog: (obj: GetTransitGatewayAttachmentPropagationsRequest) => any;
}

export interface TransitGatewayAttachmentPropagation {
    
    TransitGatewayRouteTableId?: string;
    
    State?: TransitGatewayPropagationState | string;
}
export declare namespace TransitGatewayAttachmentPropagation {
    
    const filterSensitiveLog: (obj: TransitGatewayAttachmentPropagation) => any;
}
export interface GetTransitGatewayAttachmentPropagationsResult {
    
    TransitGatewayAttachmentPropagations?: TransitGatewayAttachmentPropagation[];
    
    NextToken?: string;
}
export declare namespace GetTransitGatewayAttachmentPropagationsResult {
    
    const filterSensitiveLog: (obj: GetTransitGatewayAttachmentPropagationsResult) => any;
}
export interface GetTransitGatewayMulticastDomainAssociationsRequest {
    
    TransitGatewayMulticastDomainId?: string;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace GetTransitGatewayMulticastDomainAssociationsRequest {
    
    const filterSensitiveLog: (obj: GetTransitGatewayMulticastDomainAssociationsRequest) => any;
}

export interface TransitGatewayMulticastDomainAssociation {
    
    TransitGatewayAttachmentId?: string;
    
    ResourceId?: string;
    
    ResourceType?: TransitGatewayAttachmentResourceType | string;
    
    ResourceOwnerId?: string;
    
    Subnet?: SubnetAssociation;
}
export declare namespace TransitGatewayMulticastDomainAssociation {
    
    const filterSensitiveLog: (obj: TransitGatewayMulticastDomainAssociation) => any;
}
export interface GetTransitGatewayMulticastDomainAssociationsResult {
    
    MulticastDomainAssociations?: TransitGatewayMulticastDomainAssociation[];
    
    NextToken?: string;
}
export declare namespace GetTransitGatewayMulticastDomainAssociationsResult {
    
    const filterSensitiveLog: (obj: GetTransitGatewayMulticastDomainAssociationsResult) => any;
}
export interface GetTransitGatewayPrefixListReferencesRequest {
    
    TransitGatewayRouteTableId: string | undefined;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace GetTransitGatewayPrefixListReferencesRequest {
    
    const filterSensitiveLog: (obj: GetTransitGatewayPrefixListReferencesRequest) => any;
}
export interface GetTransitGatewayPrefixListReferencesResult {
    
    TransitGatewayPrefixListReferences?: TransitGatewayPrefixListReference[];
    
    NextToken?: string;
}
export declare namespace GetTransitGatewayPrefixListReferencesResult {
    
    const filterSensitiveLog: (obj: GetTransitGatewayPrefixListReferencesResult) => any;
}
export interface GetTransitGatewayRouteTableAssociationsRequest {
    
    TransitGatewayRouteTableId: string | undefined;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace GetTransitGatewayRouteTableAssociationsRequest {
    
    const filterSensitiveLog: (obj: GetTransitGatewayRouteTableAssociationsRequest) => any;
}

export interface TransitGatewayRouteTableAssociation {
    
    TransitGatewayAttachmentId?: string;
    
    ResourceId?: string;
    
    ResourceType?: TransitGatewayAttachmentResourceType | string;
    
    State?: TransitGatewayAssociationState | string;
}
export declare namespace TransitGatewayRouteTableAssociation {
    
    const filterSensitiveLog: (obj: TransitGatewayRouteTableAssociation) => any;
}
export interface GetTransitGatewayRouteTableAssociationsResult {
    
    Associations?: TransitGatewayRouteTableAssociation[];
    
    NextToken?: string;
}
export declare namespace GetTransitGatewayRouteTableAssociationsResult {
    
    const filterSensitiveLog: (obj: GetTransitGatewayRouteTableAssociationsResult) => any;
}
export interface GetTransitGatewayRouteTablePropagationsRequest {
    
    TransitGatewayRouteTableId: string | undefined;
    
    Filters?: Filter[];
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace GetTransitGatewayRouteTablePropagationsRequest {
    
    const filterSensitiveLog: (obj: GetTransitGatewayRouteTablePropagationsRequest) => any;
}

export interface TransitGatewayRouteTablePropagation {
    
    TransitGatewayAttachmentId?: string;
    
    ResourceId?: string;
    
    ResourceType?: TransitGatewayAttachmentResourceType | string;
    
    State?: TransitGatewayPropagationState | string;
}
export declare namespace TransitGatewayRouteTablePropagation {
    
    const filterSensitiveLog: (obj: TransitGatewayRouteTablePropagation) => any;
}
export interface GetTransitGatewayRouteTablePropagationsResult {
    
    TransitGatewayRouteTablePropagations?: TransitGatewayRouteTablePropagation[];
    
    NextToken?: string;
}
export declare namespace GetTransitGatewayRouteTablePropagationsResult {
    
    const filterSensitiveLog: (obj: GetTransitGatewayRouteTablePropagationsResult) => any;
}
export interface GetVpnConnectionDeviceSampleConfigurationRequest {
    
    VpnConnectionId: string | undefined;
    
    VpnConnectionDeviceTypeId: string | undefined;
    
    InternetKeyExchangeVersion?: string;
    
    DryRun?: boolean;
}
export declare namespace GetVpnConnectionDeviceSampleConfigurationRequest {
    
    const filterSensitiveLog: (obj: GetVpnConnectionDeviceSampleConfigurationRequest) => any;
}
export interface GetVpnConnectionDeviceSampleConfigurationResult {
    
    VpnConnectionDeviceSampleConfiguration?: string;
}
export declare namespace GetVpnConnectionDeviceSampleConfigurationResult {
    
    const filterSensitiveLog: (obj: GetVpnConnectionDeviceSampleConfigurationResult) => any;
}
export interface GetVpnConnectionDeviceTypesRequest {
    
    MaxResults?: number;
    
    NextToken?: string;
    
    DryRun?: boolean;
}
export declare namespace GetVpnConnectionDeviceTypesRequest {
    
    const filterSensitiveLog: (obj: GetVpnConnectionDeviceTypesRequest) => any;
}

export interface VpnConnectionDeviceType {
    
    VpnConnectionDeviceTypeId?: string;
    
    Vendor?: string;
    
    Platform?: string;
    
    Software?: string;
}
export declare namespace VpnConnectionDeviceType {
    
    const filterSensitiveLog: (obj: VpnConnectionDeviceType) => any;
}
export interface GetVpnConnectionDeviceTypesResult {
    
    VpnConnectionDeviceTypes?: VpnConnectionDeviceType[];
    
    NextToken?: string;
}
export declare namespace GetVpnConnectionDeviceTypesResult {
    
    const filterSensitiveLog: (obj: GetVpnConnectionDeviceTypesResult) => any;
}
export interface ImportClientVpnClientCertificateRevocationListRequest {
    
    ClientVpnEndpointId: string | undefined;
    
    CertificateRevocationList: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace ImportClientVpnClientCertificateRevocationListRequest {
    
    const filterSensitiveLog: (obj: ImportClientVpnClientCertificateRevocationListRequest) => any;
}
export interface ImportClientVpnClientCertificateRevocationListResult {
    
    Return?: boolean;
}
export declare namespace ImportClientVpnClientCertificateRevocationListResult {
    
    const filterSensitiveLog: (obj: ImportClientVpnClientCertificateRevocationListResult) => any;
}

export interface ClientData {
    
    Comment?: string;
    
    UploadEnd?: Date;
    
    UploadSize?: number;
    
    UploadStart?: Date;
}
export declare namespace ClientData {
    
    const filterSensitiveLog: (obj: ClientData) => any;
}

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

export interface ImageDiskContainer {
    
    Description?: string;
    
    DeviceName?: string;
    
    Format?: string;
    
    SnapshotId?: string;
    
    Url?: string;
    
    UserBucket?: UserBucket;
}
export declare namespace ImageDiskContainer {
    
    const filterSensitiveLog: (obj: ImageDiskContainer) => any;
}

export interface ImportImageLicenseConfigurationRequest {
    
    LicenseConfigurationArn?: string;
}
export declare namespace ImportImageLicenseConfigurationRequest {
    
    const filterSensitiveLog: (obj: ImportImageLicenseConfigurationRequest) => any;
}
export interface ImportImageRequest {
    
    Architecture?: string;
    
    ClientData?: ClientData;
    
    ClientToken?: string;
    
    Description?: string;
    
    DiskContainers?: ImageDiskContainer[];
    
    DryRun?: boolean;
    
    Encrypted?: boolean;
    
    Hypervisor?: string;
    
    KmsKeyId?: string;
    
    LicenseType?: string;
    
    Platform?: string;
    
    RoleName?: string;
    
    LicenseSpecifications?: ImportImageLicenseConfigurationRequest[];
    
    TagSpecifications?: TagSpecification[];
    
    UsageOperation?: string;
    
    BootMode?: BootModeValues | string;
}
export declare namespace ImportImageRequest {
    
    const filterSensitiveLog: (obj: ImportImageRequest) => any;
}
export interface ImportImageResult {
    
    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;
    
    LicenseSpecifications?: ImportImageLicenseConfigurationResponse[];
    
    Tags?: Tag[];
    
    UsageOperation?: string;
}
export declare namespace ImportImageResult {
    
    const filterSensitiveLog: (obj: ImportImageResult) => any;
}

export interface DiskImageDetail {
    
    Bytes: number | undefined;
    
    Format: DiskImageFormat | string | undefined;
    
    ImportManifestUrl: string | undefined;
}
export declare namespace DiskImageDetail {
    
    const filterSensitiveLog: (obj: DiskImageDetail) => any;
}

export interface VolumeDetail {
    
    Size: number | undefined;
}
export declare namespace VolumeDetail {
    
    const filterSensitiveLog: (obj: VolumeDetail) => any;
}

export interface DiskImage {
    
    Description?: string;
    
    Image?: DiskImageDetail;
    
    Volume?: VolumeDetail;
}
export declare namespace DiskImage {
    
    const filterSensitiveLog: (obj: DiskImage) => any;
}

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

export interface ImportInstanceLaunchSpecification {
    
    AdditionalInfo?: string;
    
    Architecture?: ArchitectureValues | string;
    
    GroupIds?: string[];
    
    GroupNames?: string[];
    
    InstanceInitiatedShutdownBehavior?: ShutdownBehavior | string;
    
    InstanceType?: _InstanceType | string;
    
    Monitoring?: boolean;
    
    Placement?: Placement;
    
    PrivateIpAddress?: string;
    
    SubnetId?: string;
    
    UserData?: UserData;
}
export declare namespace ImportInstanceLaunchSpecification {
    
    const filterSensitiveLog: (obj: ImportInstanceLaunchSpecification) => any;
}
export interface ImportInstanceRequest {
    
    Description?: string;
    
    DiskImages?: DiskImage[];
    
    DryRun?: boolean;
    
    LaunchSpecification?: ImportInstanceLaunchSpecification;
    
    Platform: PlatformValues | string | undefined;
}
export declare namespace ImportInstanceRequest {
    
    const filterSensitiveLog: (obj: ImportInstanceRequest) => any;
}
export interface ImportInstanceResult {
    
    ConversionTask?: ConversionTask;
}
export declare namespace ImportInstanceResult {
    
    const filterSensitiveLog: (obj: ImportInstanceResult) => any;
}
export interface ImportKeyPairRequest {
    
    DryRun?: boolean;
    
    KeyName: string | undefined;
    
    PublicKeyMaterial: Uint8Array | undefined;
    
    TagSpecifications?: TagSpecification[];
}
export declare namespace ImportKeyPairRequest {
    
    const filterSensitiveLog: (obj: ImportKeyPairRequest) => any;
}
export interface ImportKeyPairResult {
    
    KeyFingerprint?: string;
    
    KeyName?: string;
    
    KeyPairId?: string;
    
    Tags?: Tag[];
}
export declare namespace ImportKeyPairResult {
    
    const filterSensitiveLog: (obj: ImportKeyPairResult) => any;
}

export interface SnapshotDiskContainer {
    
    Description?: string;
    
    Format?: string;
    
    Url?: string;
    
    UserBucket?: UserBucket;
}
export declare namespace SnapshotDiskContainer {
    
    const filterSensitiveLog: (obj: SnapshotDiskContainer) => any;
}
export interface ImportSnapshotRequest {
    
    ClientData?: ClientData;
    
    ClientToken?: string;
    
    Description?: string;
    
    DiskContainer?: SnapshotDiskContainer;
    
    DryRun?: boolean;
    
    Encrypted?: boolean;
    
    KmsKeyId?: string;
    
    RoleName?: string;
    
    TagSpecifications?: TagSpecification[];
}
export declare namespace ImportSnapshotRequest {
    
    const filterSensitiveLog: (obj: ImportSnapshotRequest) => any;
}
export interface ImportSnapshotResult {
    
    Description?: string;
    
    ImportTaskId?: string;
    
    SnapshotTaskDetail?: SnapshotTaskDetail;
    
    Tags?: Tag[];
}
export declare namespace ImportSnapshotResult {
    
    const filterSensitiveLog: (obj: ImportSnapshotResult) => any;
}
export interface ImportVolumeRequest {
    
    AvailabilityZone: string | undefined;
    
    Description?: string;
    
    DryRun?: boolean;
    
    Image: DiskImageDetail | undefined;
    
    Volume: VolumeDetail | undefined;
}
export declare namespace ImportVolumeRequest {
    
    const filterSensitiveLog: (obj: ImportVolumeRequest) => any;
}
export interface ImportVolumeResult {
    
    ConversionTask?: ConversionTask;
}
export declare namespace ImportVolumeResult {
    
    const filterSensitiveLog: (obj: ImportVolumeResult) => any;
}
export interface ModifyAddressAttributeRequest {
    
    AllocationId: string | undefined;
    
    DomainName?: string;
    
    DryRun?: boolean;
}
export declare namespace ModifyAddressAttributeRequest {
    
    const filterSensitiveLog: (obj: ModifyAddressAttributeRequest) => any;
}
export interface ModifyAddressAttributeResult {
    
    Address?: AddressAttribute;
}
export declare namespace ModifyAddressAttributeResult {
    
    const filterSensitiveLog: (obj: ModifyAddressAttributeResult) => any;
}
export declare type ModifyAvailabilityZoneOptInStatus = "not-opted-in" | "opted-in";
export interface ModifyAvailabilityZoneGroupRequest {
    
    GroupName: string | undefined;
    
    OptInStatus: ModifyAvailabilityZoneOptInStatus | string | undefined;
    
    DryRun?: boolean;
}
export declare namespace ModifyAvailabilityZoneGroupRequest {
    
    const filterSensitiveLog: (obj: ModifyAvailabilityZoneGroupRequest) => any;
}
export interface ModifyAvailabilityZoneGroupResult {
    
    Return?: boolean;
}
export declare namespace ModifyAvailabilityZoneGroupResult {
    
    const filterSensitiveLog: (obj: ModifyAvailabilityZoneGroupResult) => any;
}
export interface ModifyCapacityReservationRequest {
    
    CapacityReservationId: string | undefined;
    
    InstanceCount?: number;
    
    EndDate?: Date;
    
    EndDateType?: EndDateType | string;
    
    Accept?: boolean;
    
    DryRun?: boolean;
    
    AdditionalInfo?: string;
}
export declare namespace ModifyCapacityReservationRequest {
    
    const filterSensitiveLog: (obj: ModifyCapacityReservationRequest) => any;
}
export interface ModifyCapacityReservationResult {
    
    Return?: boolean;
}
export declare namespace ModifyCapacityReservationResult {
    
    const filterSensitiveLog: (obj: ModifyCapacityReservationResult) => any;
}
export interface ModifyCapacityReservationFleetRequest {
    
    CapacityReservationFleetId: string | undefined;
    
    TotalTargetCapacity?: number;
    
    EndDate?: Date;
    
    DryRun?: boolean;
    
    RemoveEndDate?: boolean;
}
export declare namespace ModifyCapacityReservationFleetRequest {
    
    const filterSensitiveLog: (obj: ModifyCapacityReservationFleetRequest) => any;
}
export interface ModifyCapacityReservationFleetResult {
    
    Return?: boolean;
}
export declare namespace ModifyCapacityReservationFleetResult {
    
    const filterSensitiveLog: (obj: ModifyCapacityReservationFleetResult) => any;
}

export interface DnsServersOptionsModifyStructure {
    
    CustomDnsServers?: string[];
    
    Enabled?: boolean;
}
export declare namespace DnsServersOptionsModifyStructure {
    
    const filterSensitiveLog: (obj: DnsServersOptionsModifyStructure) => any;
}
export interface ModifyClientVpnEndpointRequest {
    
    ClientVpnEndpointId: string | undefined;
    
    ServerCertificateArn?: string;
    
    ConnectionLogOptions?: ConnectionLogOptions;
    
    DnsServers?: DnsServersOptionsModifyStructure;
    
    VpnPort?: number;
    
    Description?: string;
    
    SplitTunnel?: boolean;
    
    DryRun?: boolean;
    
    SecurityGroupIds?: string[];
    
    VpcId?: string;
    
    SelfServicePortal?: SelfServicePortal | string;
    
    ClientConnectOptions?: ClientConnectOptions;
}
export declare namespace ModifyClientVpnEndpointRequest {
    
    const filterSensitiveLog: (obj: ModifyClientVpnEndpointRequest) => any;
}
export interface ModifyClientVpnEndpointResult {
    
    Return?: boolean;
}
export declare namespace ModifyClientVpnEndpointResult {
    
    const filterSensitiveLog: (obj: ModifyClientVpnEndpointResult) => any;
}
export interface ModifyDefaultCreditSpecificationRequest {
    
    DryRun?: boolean;
    
    InstanceFamily: UnlimitedSupportedInstanceFamily | string | undefined;
    
    CpuCredits: string | undefined;
}
export declare namespace ModifyDefaultCreditSpecificationRequest {
    
    const filterSensitiveLog: (obj: ModifyDefaultCreditSpecificationRequest) => any;
}
export interface ModifyDefaultCreditSpecificationResult {
    
    InstanceFamilyCreditSpecification?: InstanceFamilyCreditSpecification;
}
export declare namespace ModifyDefaultCreditSpecificationResult {
    
    const filterSensitiveLog: (obj: ModifyDefaultCreditSpecificationResult) => any;
}
export interface ModifyEbsDefaultKmsKeyIdRequest {
    
    KmsKeyId: string | undefined;
    
    DryRun?: boolean;
}
export declare namespace ModifyEbsDefaultKmsKeyIdRequest {
    
    const filterSensitiveLog: (obj: ModifyEbsDefaultKmsKeyIdRequest) => any;
}
export interface ModifyEbsDefaultKmsKeyIdResult {
    
    KmsKeyId?: string;
}
export declare namespace ModifyEbsDefaultKmsKeyIdResult {
    
    const filterSensitiveLog: (obj: ModifyEbsDefaultKmsKeyIdResult) => any;
}
export interface ModifyFleetRequest {
    
    DryRun?: boolean;
    
    ExcessCapacityTerminationPolicy?: FleetExcessCapacityTerminationPolicy | string;
    
    LaunchTemplateConfigs?: FleetLaunchTemplateConfigRequest[];
    
    FleetId: string | undefined;
    
    TargetCapacitySpecification?: TargetCapacitySpecificationRequest;
    
    Context?: string;
}
export declare namespace ModifyFleetRequest {
    
    const filterSensitiveLog: (obj: ModifyFleetRequest) => any;
}
export interface ModifyFleetResult {
    
    Return?: boolean;
}
export declare namespace ModifyFleetResult {
    
    const filterSensitiveLog: (obj: ModifyFleetResult) => any;
}

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

export interface LoadPermissionModifications {
    
    Add?: LoadPermissionRequest[];
    
    Remove?: LoadPermissionRequest[];
}
export declare namespace LoadPermissionModifications {
    
    const filterSensitiveLog: (obj: LoadPermissionModifications) => any;
}
export declare type OperationType = "add" | "remove";
export interface ModifyFpgaImageAttributeRequest {
    
    DryRun?: boolean;
    
    FpgaImageId: string | undefined;
    
    Attribute?: FpgaImageAttributeName | string;
    
    OperationType?: OperationType | string;
    
    UserIds?: string[];
    
    UserGroups?: string[];
    
    ProductCodes?: string[];
    
    LoadPermission?: LoadPermissionModifications;
    
    Description?: string;
    
    Name?: string;
}
export declare namespace ModifyFpgaImageAttributeRequest {
    
    const filterSensitiveLog: (obj: ModifyFpgaImageAttributeRequest) => any;
}
export interface ModifyFpgaImageAttributeResult {
    
    FpgaImageAttribute?: FpgaImageAttribute;
}
export declare namespace ModifyFpgaImageAttributeResult {
    
    const filterSensitiveLog: (obj: ModifyFpgaImageAttributeResult) => any;
}
export interface ModifyHostsRequest {
    
    AutoPlacement?: AutoPlacement | string;
    
    HostIds: string[] | undefined;
    
    HostRecovery?: HostRecovery | string;
    
    InstanceType?: string;
    
    InstanceFamily?: string;
}
export declare namespace ModifyHostsRequest {
    
    const filterSensitiveLog: (obj: ModifyHostsRequest) => any;
}
export interface ModifyHostsResult {
    
    Successful?: string[];
    
    Unsuccessful?: UnsuccessfulItem[];
}
export declare namespace ModifyHostsResult {
    
    const filterSensitiveLog: (obj: ModifyHostsResult) => any;
}
export interface ModifyIdentityIdFormatRequest {
    
    PrincipalArn: string | undefined;
    
    Resource: string | undefined;
    
    UseLongIds: boolean | undefined;
}
export declare namespace ModifyIdentityIdFormatRequest {
    
    const filterSensitiveLog: (obj: ModifyIdentityIdFormatRequest) => any;
}
export interface ModifyIdFormatRequest {
    
    Resource: string | undefined;
    
    UseLongIds: boolean | undefined;
}
export declare namespace ModifyIdFormatRequest {
    
    const filterSensitiveLog: (obj: ModifyIdFormatRequest) => any;
}

export interface LaunchPermissionModifications {
    
    Add?: LaunchPermission[];
    
    Remove?: LaunchPermission[];
}
export declare namespace LaunchPermissionModifications {
    
    const filterSensitiveLog: (obj: LaunchPermissionModifications) => any;
}

export interface ModifyImageAttributeRequest {
    
    Attribute?: string;
    
    Description?: AttributeValue;
    
    ImageId: string | undefined;
    
    LaunchPermission?: LaunchPermissionModifications;
    
    OperationType?: OperationType | string;
    
    ProductCodes?: string[];
    
    UserGroups?: string[];
    
    UserIds?: string[];
    
    Value?: string;
    
    DryRun?: boolean;
    
    OrganizationArns?: string[];
    
    OrganizationalUnitArns?: string[];
}
export declare namespace ModifyImageAttributeRequest {
    
    const filterSensitiveLog: (obj: ModifyImageAttributeRequest) => any;
}

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

export interface InstanceBlockDeviceMappingSpecification {
    
    DeviceName?: string;
    
    Ebs?: EbsInstanceBlockDeviceSpecification;
    
    NoDevice?: string;
    
    VirtualName?: string;
}
export declare namespace InstanceBlockDeviceMappingSpecification {
    
    const filterSensitiveLog: (obj: InstanceBlockDeviceMappingSpecification) => any;
}
export interface BlobAttributeValue {
    Value?: Uint8Array;
}
export declare namespace BlobAttributeValue {
    
    const filterSensitiveLog: (obj: BlobAttributeValue) => any;
}
export interface ModifyInstanceAttributeRequest {
    
    SourceDestCheck?: AttributeBooleanValue;
    
    Attribute?: InstanceAttributeName | string;
    
    BlockDeviceMappings?: InstanceBlockDeviceMappingSpecification[];
    
    DisableApiTermination?: AttributeBooleanValue;
    
    DryRun?: boolean;
    
    EbsOptimized?: AttributeBooleanValue;
    
    EnaSupport?: AttributeBooleanValue;
    
    Groups?: string[];
    
    InstanceId: string | undefined;
    
    InstanceInitiatedShutdownBehavior?: AttributeValue;
    
    InstanceType?: AttributeValue;
    
    Kernel?: AttributeValue;
    
    Ramdisk?: AttributeValue;
    
    SriovNetSupport?: AttributeValue;
    
    UserData?: BlobAttributeValue;
    
    Value?: string;
}
export declare namespace ModifyInstanceAttributeRequest {
    
    const filterSensitiveLog: (obj: ModifyInstanceAttributeRequest) => any;
}

export interface CapacityReservationSpecification {
    
    CapacityReservationPreference?: CapacityReservationPreference | string;
    
    CapacityReservationTarget?: CapacityReservationTarget;
}
export declare namespace CapacityReservationSpecification {
    
    const filterSensitiveLog: (obj: CapacityReservationSpecification) => any;
}
export interface ModifyInstanceCapacityReservationAttributesRequest {
    
    InstanceId: string | undefined;
    
    CapacityReservationSpecification: CapacityReservationSpecification | undefined;
    
    DryRun?: boolean;
}
export declare namespace ModifyInstanceCapacityReservationAttributesRequest {
    
    const filterSensitiveLog: (obj: ModifyInstanceCapacityReservationAttributesRequest) => any;
}
export interface ModifyInstanceCapacityReservationAttributesResult {
    
    Return?: boolean;
}
export declare namespace ModifyInstanceCapacityReservationAttributesResult {
    
    const filterSensitiveLog: (obj: ModifyInstanceCapacityReservationAttributesResult) => any;
}

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