@aws-sdk/client-networkmanager 3.50.0 → 3.53.0

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

@@ -0,0 +1,2818 @@
+import { ExceptionOptionType as __ExceptionOptionType, LazyJsonString as __LazyJsonString } from "@aws-sdk/smithy-client";
+import { NetworkManagerServiceException as __BaseException } from "./NetworkManagerServiceException";
+export interface AcceptAttachmentRequest {
+    
+    AttachmentId: string | undefined;
+}
+export declare namespace AcceptAttachmentRequest {
+    
+    const filterSensitiveLog: (obj: AcceptAttachmentRequest) => any;
+}
+export declare enum AttachmentType {
+    CONNECT = "CONNECT",
+    SITE_TO_SITE_VPN = "SITE_TO_SITE_VPN",
+    VPC = "VPC"
+}
+
+export interface Tag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface ProposedSegmentChange {
+    
+    Tags?: Tag[];
+    
+    AttachmentPolicyRuleNumber?: number;
+    
+    SegmentName?: string;
+}
+export declare namespace ProposedSegmentChange {
+    
+    const filterSensitiveLog: (obj: ProposedSegmentChange) => any;
+}
+export declare enum AttachmentState {
+    AVAILABLE = "AVAILABLE",
+    CREATING = "CREATING",
+    DELETING = "DELETING",
+    FAILED = "FAILED",
+    PENDING_ATTACHMENT_ACCEPTANCE = "PENDING_ATTACHMENT_ACCEPTANCE",
+    PENDING_NETWORK_UPDATE = "PENDING_NETWORK_UPDATE",
+    PENDING_TAG_ACCEPTANCE = "PENDING_TAG_ACCEPTANCE",
+    REJECTED = "REJECTED",
+    UPDATING = "UPDATING"
+}
+
+export interface Attachment {
+    
+    CoreNetworkId?: string;
+    
+    CoreNetworkArn?: string;
+    
+    AttachmentId?: string;
+    
+    OwnerAccountId?: string;
+    
+    AttachmentType?: AttachmentType | string;
+    
+    State?: AttachmentState | string;
+    
+    EdgeLocation?: string;
+    
+    ResourceArn?: string;
+    
+    AttachmentPolicyRuleNumber?: number;
+    
+    SegmentName?: string;
+    
+    Tags?: Tag[];
+    
+    ProposedSegmentChange?: ProposedSegmentChange;
+    
+    CreatedAt?: Date;
+    
+    UpdatedAt?: Date;
+}
+export declare namespace Attachment {
+    
+    const filterSensitiveLog: (obj: Attachment) => any;
+}
+export interface AcceptAttachmentResponse {
+    
+    Attachment?: Attachment;
+}
+export declare namespace AcceptAttachmentResponse {
+    
+    const filterSensitiveLog: (obj: AcceptAttachmentResponse) => any;
+}
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    ResourceId: string | undefined;
+    
+    ResourceType: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    Message: string | undefined;
+    
+    RetryAfterSeconds?: number;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    ResourceId: string | undefined;
+    
+    ResourceType: string | undefined;
+    
+    Context?: {
+        [key: string]: string;
+    };
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    RetryAfterSeconds?: number;
+    
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+
+export interface ValidationExceptionField {
+    
+    Name: string | undefined;
+    
+    Message: string | undefined;
+}
+export declare namespace ValidationExceptionField {
+    
+    const filterSensitiveLog: (obj: ValidationExceptionField) => any;
+}
+export declare enum ValidationExceptionReason {
+    CANNOT_PARSE = "CannotParse",
+    FIELD_VALIDATION_FAILED = "FieldValidationFailed",
+    OTHER = "Other",
+    UNKNOWN_OPERATION = "UnknownOperation"
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    Reason?: ValidationExceptionReason | string;
+    
+    Fields?: ValidationExceptionField[];
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+export interface AssociateConnectPeerRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    ConnectPeerId: string | undefined;
+    
+    DeviceId: string | undefined;
+    
+    LinkId?: string;
+}
+export declare namespace AssociateConnectPeerRequest {
+    
+    const filterSensitiveLog: (obj: AssociateConnectPeerRequest) => any;
+}
+export declare enum ConnectPeerAssociationState {
+    available = "AVAILABLE",
+    deleted = "DELETED",
+    deleting = "DELETING",
+    pending = "PENDING"
+}
+
+export interface ConnectPeerAssociation {
+    
+    ConnectPeerId?: string;
+    
+    GlobalNetworkId?: string;
+    
+    DeviceId?: string;
+    
+    LinkId?: string;
+    
+    State?: ConnectPeerAssociationState | string;
+}
+export declare namespace ConnectPeerAssociation {
+    
+    const filterSensitiveLog: (obj: ConnectPeerAssociation) => any;
+}
+export interface AssociateConnectPeerResponse {
+    
+    ConnectPeerAssociation?: ConnectPeerAssociation;
+}
+export declare namespace AssociateConnectPeerResponse {
+    
+    const filterSensitiveLog: (obj: AssociateConnectPeerResponse) => any;
+}
+
+export declare class ServiceQuotaExceededException extends __BaseException {
+    readonly name: "ServiceQuotaExceededException";
+    readonly $fault: "client";
+    
+    Message: string | undefined;
+    
+    ResourceId?: string;
+    
+    ResourceType?: string;
+    
+    LimitCode: string | undefined;
+    
+    ServiceCode: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>);
+}
+export interface AssociateCustomerGatewayRequest {
+    
+    CustomerGatewayArn: string | undefined;
+    
+    GlobalNetworkId: string | undefined;
+    
+    DeviceId: string | undefined;
+    
+    LinkId?: string;
+}
+export declare namespace AssociateCustomerGatewayRequest {
+    
+    const filterSensitiveLog: (obj: AssociateCustomerGatewayRequest) => any;
+}
+export declare enum CustomerGatewayAssociationState {
+    available = "AVAILABLE",
+    deleted = "DELETED",
+    deleting = "DELETING",
+    pending = "PENDING"
+}
+
+export interface CustomerGatewayAssociation {
+    
+    CustomerGatewayArn?: string;
+    
+    GlobalNetworkId?: string;
+    
+    DeviceId?: string;
+    
+    LinkId?: string;
+    
+    State?: CustomerGatewayAssociationState | string;
+}
+export declare namespace CustomerGatewayAssociation {
+    
+    const filterSensitiveLog: (obj: CustomerGatewayAssociation) => any;
+}
+export interface AssociateCustomerGatewayResponse {
+    
+    CustomerGatewayAssociation?: CustomerGatewayAssociation;
+}
+export declare namespace AssociateCustomerGatewayResponse {
+    
+    const filterSensitiveLog: (obj: AssociateCustomerGatewayResponse) => any;
+}
+export interface AssociateLinkRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    DeviceId: string | undefined;
+    
+    LinkId: string | undefined;
+}
+export declare namespace AssociateLinkRequest {
+    
+    const filterSensitiveLog: (obj: AssociateLinkRequest) => any;
+}
+export declare enum LinkAssociationState {
+    available = "AVAILABLE",
+    deleted = "DELETED",
+    deleting = "DELETING",
+    pending = "PENDING"
+}
+
+export interface LinkAssociation {
+    
+    GlobalNetworkId?: string;
+    
+    DeviceId?: string;
+    
+    LinkId?: string;
+    
+    LinkAssociationState?: LinkAssociationState | string;
+}
+export declare namespace LinkAssociation {
+    
+    const filterSensitiveLog: (obj: LinkAssociation) => any;
+}
+export interface AssociateLinkResponse {
+    
+    LinkAssociation?: LinkAssociation;
+}
+export declare namespace AssociateLinkResponse {
+    
+    const filterSensitiveLog: (obj: AssociateLinkResponse) => any;
+}
+export interface AssociateTransitGatewayConnectPeerRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    TransitGatewayConnectPeerArn: string | undefined;
+    
+    DeviceId: string | undefined;
+    
+    LinkId?: string;
+}
+export declare namespace AssociateTransitGatewayConnectPeerRequest {
+    
+    const filterSensitiveLog: (obj: AssociateTransitGatewayConnectPeerRequest) => any;
+}
+export declare enum TransitGatewayConnectPeerAssociationState {
+    available = "AVAILABLE",
+    deleted = "DELETED",
+    deleting = "DELETING",
+    pending = "PENDING"
+}
+
+export interface TransitGatewayConnectPeerAssociation {
+    
+    TransitGatewayConnectPeerArn?: string;
+    
+    GlobalNetworkId?: string;
+    
+    DeviceId?: string;
+    
+    LinkId?: string;
+    
+    State?: TransitGatewayConnectPeerAssociationState | string;
+}
+export declare namespace TransitGatewayConnectPeerAssociation {
+    
+    const filterSensitiveLog: (obj: TransitGatewayConnectPeerAssociation) => any;
+}
+export interface AssociateTransitGatewayConnectPeerResponse {
+    
+    TransitGatewayConnectPeerAssociation?: TransitGatewayConnectPeerAssociation;
+}
+export declare namespace AssociateTransitGatewayConnectPeerResponse {
+    
+    const filterSensitiveLog: (obj: AssociateTransitGatewayConnectPeerResponse) => any;
+}
+
+export interface AWSLocation {
+    
+    Zone?: string;
+    
+    SubnetArn?: string;
+}
+export declare namespace AWSLocation {
+    
+    const filterSensitiveLog: (obj: AWSLocation) => any;
+}
+
+export interface Bandwidth {
+    
+    UploadSpeed?: number;
+    
+    DownloadSpeed?: number;
+}
+export declare namespace Bandwidth {
+    
+    const filterSensitiveLog: (obj: Bandwidth) => any;
+}
+
+export interface BgpOptions {
+    
+    PeerAsn?: number;
+}
+export declare namespace BgpOptions {
+    
+    const filterSensitiveLog: (obj: BgpOptions) => any;
+}
+export declare enum ChangeAction {
+    ADD = "ADD",
+    MODIFY = "MODIFY",
+    REMOVE = "REMOVE"
+}
+export declare enum ChangeSetState {
+    EXECUTING = "EXECUTING",
+    EXECUTION_SUCCEEDED = "EXECUTION_SUCCEEDED",
+    FAILED_GENERATION = "FAILED_GENERATION",
+    OUT_OF_DATE = "OUT_OF_DATE",
+    PENDING_GENERATION = "PENDING_GENERATION",
+    READY_TO_EXECUTE = "READY_TO_EXECUTE"
+}
+export declare enum ChangeType {
+    ATTACHMENT_MAPPING = "ATTACHMENT_MAPPING",
+    ATTACHMENT_ROUTE_PROPAGATION = "ATTACHMENT_ROUTE_PROPAGATION",
+    ATTACHMENT_ROUTE_STATIC = "ATTACHMENT_ROUTE_STATIC",
+    CORE_NETWORK_EDGE = "CORE_NETWORK_EDGE",
+    CORE_NETWORK_SEGMENT = "CORE_NETWORK_SEGMENT"
+}
+export declare enum TunnelProtocol {
+    GRE = "GRE"
+}
+
+export interface ConnectAttachmentOptions {
+    
+    Protocol?: TunnelProtocol | string;
+}
+export declare namespace ConnectAttachmentOptions {
+    
+    const filterSensitiveLog: (obj: ConnectAttachmentOptions) => any;
+}
+
+export interface ConnectAttachment {
+    
+    Attachment?: Attachment;
+    
+    TransportAttachmentId?: string;
+    
+    Options?: ConnectAttachmentOptions;
+}
+export declare namespace ConnectAttachment {
+    
+    const filterSensitiveLog: (obj: ConnectAttachment) => any;
+}
+export declare enum ConnectionState {
+    available = "AVAILABLE",
+    deleting = "DELETING",
+    pending = "PENDING",
+    updating = "UPDATING"
+}
+
+export interface Connection {
+    
+    ConnectionId?: string;
+    
+    ConnectionArn?: string;
+    
+    GlobalNetworkId?: string;
+    
+    DeviceId?: string;
+    
+    ConnectedDeviceId?: string;
+    
+    LinkId?: string;
+    
+    ConnectedLinkId?: string;
+    
+    Description?: string;
+    
+    CreatedAt?: Date;
+    
+    State?: ConnectionState | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace Connection {
+    
+    const filterSensitiveLog: (obj: Connection) => any;
+}
+export declare enum ConnectionStatus {
+    DOWN = "DOWN",
+    UP = "UP"
+}
+export declare enum ConnectionType {
+    BGP = "BGP",
+    IPSEC = "IPSEC"
+}
+
+export interface ConnectionHealth {
+    
+    Type?: ConnectionType | string;
+    
+    Status?: ConnectionStatus | string;
+    
+    Timestamp?: Date;
+}
+export declare namespace ConnectionHealth {
+    
+    const filterSensitiveLog: (obj: ConnectionHealth) => any;
+}
+
+export interface ConnectPeerBgpConfiguration {
+    
+    CoreNetworkAsn?: number;
+    
+    PeerAsn?: number;
+    
+    CoreNetworkAddress?: string;
+    
+    PeerAddress?: string;
+}
+export declare namespace ConnectPeerBgpConfiguration {
+    
+    const filterSensitiveLog: (obj: ConnectPeerBgpConfiguration) => any;
+}
+
+export interface ConnectPeerConfiguration {
+    
+    CoreNetworkAddress?: string;
+    
+    PeerAddress?: string;
+    
+    InsideCidrBlocks?: string[];
+    
+    Protocol?: TunnelProtocol | string;
+    
+    BgpConfigurations?: ConnectPeerBgpConfiguration[];
+}
+export declare namespace ConnectPeerConfiguration {
+    
+    const filterSensitiveLog: (obj: ConnectPeerConfiguration) => any;
+}
+export declare enum ConnectPeerState {
+    AVAILABLE = "AVAILABLE",
+    CREATING = "CREATING",
+    DELETING = "DELETING",
+    FAILED = "FAILED"
+}
+
+export interface ConnectPeer {
+    
+    CoreNetworkId?: string;
+    
+    ConnectAttachmentId?: string;
+    
+    ConnectPeerId?: string;
+    
+    EdgeLocation?: string;
+    
+    State?: ConnectPeerState | string;
+    
+    CreatedAt?: Date;
+    
+    Configuration?: ConnectPeerConfiguration;
+    
+    Tags?: Tag[];
+}
+export declare namespace ConnectPeer {
+    
+    const filterSensitiveLog: (obj: ConnectPeer) => any;
+}
+
+export interface ConnectPeerSummary {
+    
+    CoreNetworkId?: string;
+    
+    ConnectAttachmentId?: string;
+    
+    ConnectPeerId?: string;
+    
+    EdgeLocation?: string;
+    
+    ConnectPeerState?: ConnectPeerState | string;
+    
+    CreatedAt?: Date;
+    
+    Tags?: Tag[];
+}
+export declare namespace ConnectPeerSummary {
+    
+    const filterSensitiveLog: (obj: ConnectPeerSummary) => any;
+}
+
+export interface CoreNetworkEdge {
+    
+    EdgeLocation?: string;
+    
+    Asn?: number;
+    
+    InsideCidrBlocks?: string[];
+}
+export declare namespace CoreNetworkEdge {
+    
+    const filterSensitiveLog: (obj: CoreNetworkEdge) => any;
+}
+
+export interface CoreNetworkSegment {
+    
+    Name?: string;
+    
+    EdgeLocations?: string[];
+    
+    SharedSegments?: string[];
+}
+export declare namespace CoreNetworkSegment {
+    
+    const filterSensitiveLog: (obj: CoreNetworkSegment) => any;
+}
+export declare enum CoreNetworkState {
+    AVAILABLE = "AVAILABLE",
+    CREATING = "CREATING",
+    DELETING = "DELETING",
+    UPDATING = "UPDATING"
+}
+
+export interface CoreNetwork {
+    
+    GlobalNetworkId?: string;
+    
+    CoreNetworkId?: string;
+    
+    CoreNetworkArn?: string;
+    
+    Description?: string;
+    
+    CreatedAt?: Date;
+    
+    State?: CoreNetworkState | string;
+    
+    Segments?: CoreNetworkSegment[];
+    
+    Edges?: CoreNetworkEdge[];
+    
+    Tags?: Tag[];
+}
+export declare namespace CoreNetwork {
+    
+    const filterSensitiveLog: (obj: CoreNetwork) => any;
+}
+
+export interface CoreNetworkChangeValues {
+    
+    SegmentName?: string;
+    
+    EdgeLocations?: string[];
+    
+    Asn?: number;
+    
+    Cidr?: string;
+    
+    DestinationIdentifier?: string;
+    
+    InsideCidrBlocks?: string[];
+    
+    SharedSegments?: string[];
+}
+export declare namespace CoreNetworkChangeValues {
+    
+    const filterSensitiveLog: (obj: CoreNetworkChangeValues) => any;
+}
+
+export interface CoreNetworkChange {
+    
+    Type?: ChangeType | string;
+    
+    Action?: ChangeAction | string;
+    
+    Identifier?: string;
+    
+    PreviousValues?: CoreNetworkChangeValues;
+    
+    NewValues?: CoreNetworkChangeValues;
+}
+export declare namespace CoreNetworkChange {
+    
+    const filterSensitiveLog: (obj: CoreNetworkChange) => any;
+}
+export declare enum CoreNetworkPolicyAlias {
+    LATEST = "LATEST",
+    LIVE = "LIVE"
+}
+
+export interface CoreNetworkPolicyError {
+    
+    ErrorCode: string | undefined;
+    
+    Message: string | undefined;
+    
+    Path?: string;
+}
+export declare namespace CoreNetworkPolicyError {
+    
+    const filterSensitiveLog: (obj: CoreNetworkPolicyError) => any;
+}
+
+export interface CoreNetworkPolicy {
+    
+    CoreNetworkId?: string;
+    
+    PolicyVersionId?: number;
+    
+    Alias?: CoreNetworkPolicyAlias | string;
+    
+    Description?: string;
+    
+    CreatedAt?: Date;
+    
+    ChangeSetState?: ChangeSetState | string;
+    
+    PolicyErrors?: CoreNetworkPolicyError[];
+    
+    PolicyDocument?: __LazyJsonString | string;
+}
+export declare namespace CoreNetworkPolicy {
+    
+    const filterSensitiveLog: (obj: CoreNetworkPolicy) => any;
+}
+
+export declare class CoreNetworkPolicyException extends __BaseException {
+    readonly name: "CoreNetworkPolicyException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    Errors?: CoreNetworkPolicyError[];
+    
+    constructor(opts: __ExceptionOptionType<CoreNetworkPolicyException, __BaseException>);
+}
+
+export interface CoreNetworkPolicyVersion {
+    
+    CoreNetworkId?: string;
+    
+    PolicyVersionId?: number;
+    
+    Alias?: CoreNetworkPolicyAlias | string;
+    
+    Description?: string;
+    
+    CreatedAt?: Date;
+    
+    ChangeSetState?: ChangeSetState | string;
+}
+export declare namespace CoreNetworkPolicyVersion {
+    
+    const filterSensitiveLog: (obj: CoreNetworkPolicyVersion) => any;
+}
+
+export interface CoreNetworkSegmentEdgeIdentifier {
+    
+    CoreNetworkId?: string;
+    
+    SegmentName?: string;
+    
+    EdgeLocation?: string;
+}
+export declare namespace CoreNetworkSegmentEdgeIdentifier {
+    
+    const filterSensitiveLog: (obj: CoreNetworkSegmentEdgeIdentifier) => any;
+}
+
+export interface CoreNetworkSummary {
+    
+    CoreNetworkId?: string;
+    
+    CoreNetworkArn?: string;
+    
+    GlobalNetworkId?: string;
+    
+    OwnerAccountId?: string;
+    
+    State?: CoreNetworkState | string;
+    
+    Description?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CoreNetworkSummary {
+    
+    const filterSensitiveLog: (obj: CoreNetworkSummary) => any;
+}
+export interface CreateConnectAttachmentRequest {
+    
+    CoreNetworkId: string | undefined;
+    
+    EdgeLocation: string | undefined;
+    
+    TransportAttachmentId: string | undefined;
+    
+    Options: ConnectAttachmentOptions | undefined;
+    
+    Tags?: Tag[];
+    
+    ClientToken?: string;
+}
+export declare namespace CreateConnectAttachmentRequest {
+    
+    const filterSensitiveLog: (obj: CreateConnectAttachmentRequest) => any;
+}
+export interface CreateConnectAttachmentResponse {
+    
+    ConnectAttachment?: ConnectAttachment;
+}
+export declare namespace CreateConnectAttachmentResponse {
+    
+    const filterSensitiveLog: (obj: CreateConnectAttachmentResponse) => any;
+}
+export interface CreateConnectionRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    DeviceId: string | undefined;
+    
+    ConnectedDeviceId: string | undefined;
+    
+    LinkId?: string;
+    
+    ConnectedLinkId?: string;
+    
+    Description?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateConnectionRequest {
+    
+    const filterSensitiveLog: (obj: CreateConnectionRequest) => any;
+}
+export interface CreateConnectionResponse {
+    
+    Connection?: Connection;
+}
+export declare namespace CreateConnectionResponse {
+    
+    const filterSensitiveLog: (obj: CreateConnectionResponse) => any;
+}
+export interface CreateConnectPeerRequest {
+    
+    ConnectAttachmentId: string | undefined;
+    
+    CoreNetworkAddress?: string;
+    
+    PeerAddress: string | undefined;
+    
+    BgpOptions?: BgpOptions;
+    
+    InsideCidrBlocks: string[] | undefined;
+    
+    Tags?: Tag[];
+    
+    ClientToken?: string;
+}
+export declare namespace CreateConnectPeerRequest {
+    
+    const filterSensitiveLog: (obj: CreateConnectPeerRequest) => any;
+}
+export interface CreateConnectPeerResponse {
+    
+    ConnectPeer?: ConnectPeer;
+}
+export declare namespace CreateConnectPeerResponse {
+    
+    const filterSensitiveLog: (obj: CreateConnectPeerResponse) => any;
+}
+export interface CreateCoreNetworkRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    Description?: string;
+    
+    Tags?: Tag[];
+    
+    PolicyDocument?: string;
+    
+    ClientToken?: string;
+}
+export declare namespace CreateCoreNetworkRequest {
+    
+    const filterSensitiveLog: (obj: CreateCoreNetworkRequest) => any;
+}
+export interface CreateCoreNetworkResponse {
+    
+    CoreNetwork?: CoreNetwork;
+}
+export declare namespace CreateCoreNetworkResponse {
+    
+    const filterSensitiveLog: (obj: CreateCoreNetworkResponse) => any;
+}
+
+export interface Location {
+    
+    Address?: string;
+    
+    Latitude?: string;
+    
+    Longitude?: string;
+}
+export declare namespace Location {
+    
+    const filterSensitiveLog: (obj: Location) => any;
+}
+export interface CreateDeviceRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    AWSLocation?: AWSLocation;
+    
+    Description?: string;
+    
+    Type?: string;
+    
+    Vendor?: string;
+    
+    Model?: string;
+    
+    SerialNumber?: string;
+    
+    Location?: Location;
+    
+    SiteId?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDeviceRequest {
+    
+    const filterSensitiveLog: (obj: CreateDeviceRequest) => any;
+}
+export declare enum DeviceState {
+    available = "AVAILABLE",
+    deleting = "DELETING",
+    pending = "PENDING",
+    updating = "UPDATING"
+}
+
+export interface Device {
+    
+    DeviceId?: string;
+    
+    DeviceArn?: string;
+    
+    GlobalNetworkId?: string;
+    
+    AWSLocation?: AWSLocation;
+    
+    Description?: string;
+    
+    Type?: string;
+    
+    Vendor?: string;
+    
+    Model?: string;
+    
+    SerialNumber?: string;
+    
+    Location?: Location;
+    
+    SiteId?: string;
+    
+    CreatedAt?: Date;
+    
+    State?: DeviceState | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace Device {
+    
+    const filterSensitiveLog: (obj: Device) => any;
+}
+export interface CreateDeviceResponse {
+    
+    Device?: Device;
+}
+export declare namespace CreateDeviceResponse {
+    
+    const filterSensitiveLog: (obj: CreateDeviceResponse) => any;
+}
+export interface CreateGlobalNetworkRequest {
+    
+    Description?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateGlobalNetworkRequest {
+    
+    const filterSensitiveLog: (obj: CreateGlobalNetworkRequest) => any;
+}
+export declare enum GlobalNetworkState {
+    available = "AVAILABLE",
+    deleting = "DELETING",
+    pending = "PENDING",
+    updating = "UPDATING"
+}
+
+export interface GlobalNetwork {
+    
+    GlobalNetworkId?: string;
+    
+    GlobalNetworkArn?: string;
+    
+    Description?: string;
+    
+    CreatedAt?: Date;
+    
+    State?: GlobalNetworkState | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace GlobalNetwork {
+    
+    const filterSensitiveLog: (obj: GlobalNetwork) => any;
+}
+export interface CreateGlobalNetworkResponse {
+    
+    GlobalNetwork?: GlobalNetwork;
+}
+export declare namespace CreateGlobalNetworkResponse {
+    
+    const filterSensitiveLog: (obj: CreateGlobalNetworkResponse) => any;
+}
+export interface CreateLinkRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    Description?: string;
+    
+    Type?: string;
+    
+    Bandwidth: Bandwidth | undefined;
+    
+    Provider?: string;
+    
+    SiteId: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateLinkRequest {
+    
+    const filterSensitiveLog: (obj: CreateLinkRequest) => any;
+}
+export declare enum LinkState {
+    available = "AVAILABLE",
+    deleting = "DELETING",
+    pending = "PENDING",
+    updating = "UPDATING"
+}
+
+export interface Link {
+    
+    LinkId?: string;
+    
+    LinkArn?: string;
+    
+    GlobalNetworkId?: string;
+    
+    SiteId?: string;
+    
+    Description?: string;
+    
+    Type?: string;
+    
+    Bandwidth?: Bandwidth;
+    
+    Provider?: string;
+    
+    CreatedAt?: Date;
+    
+    State?: LinkState | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace Link {
+    
+    const filterSensitiveLog: (obj: Link) => any;
+}
+export interface CreateLinkResponse {
+    
+    Link?: Link;
+}
+export declare namespace CreateLinkResponse {
+    
+    const filterSensitiveLog: (obj: CreateLinkResponse) => any;
+}
+export interface CreateSiteRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    Description?: string;
+    
+    Location?: Location;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateSiteRequest {
+    
+    const filterSensitiveLog: (obj: CreateSiteRequest) => any;
+}
+export declare enum SiteState {
+    available = "AVAILABLE",
+    deleting = "DELETING",
+    pending = "PENDING",
+    updating = "UPDATING"
+}
+
+export interface Site {
+    
+    SiteId?: string;
+    
+    SiteArn?: string;
+    
+    GlobalNetworkId?: string;
+    
+    Description?: string;
+    
+    Location?: Location;
+    
+    CreatedAt?: Date;
+    
+    State?: SiteState | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace Site {
+    
+    const filterSensitiveLog: (obj: Site) => any;
+}
+export interface CreateSiteResponse {
+    
+    Site?: Site;
+}
+export declare namespace CreateSiteResponse {
+    
+    const filterSensitiveLog: (obj: CreateSiteResponse) => any;
+}
+export interface CreateSiteToSiteVpnAttachmentRequest {
+    
+    CoreNetworkId: string | undefined;
+    
+    VpnConnectionArn: string | undefined;
+    
+    Tags?: Tag[];
+    
+    ClientToken?: string;
+}
+export declare namespace CreateSiteToSiteVpnAttachmentRequest {
+    
+    const filterSensitiveLog: (obj: CreateSiteToSiteVpnAttachmentRequest) => any;
+}
+
+export interface SiteToSiteVpnAttachment {
+    
+    Attachment?: Attachment;
+    
+    VpnConnectionArn?: string;
+}
+export declare namespace SiteToSiteVpnAttachment {
+    
+    const filterSensitiveLog: (obj: SiteToSiteVpnAttachment) => any;
+}
+export interface CreateSiteToSiteVpnAttachmentResponse {
+    
+    SiteToSiteVpnAttachment?: SiteToSiteVpnAttachment;
+}
+export declare namespace CreateSiteToSiteVpnAttachmentResponse {
+    
+    const filterSensitiveLog: (obj: CreateSiteToSiteVpnAttachmentResponse) => any;
+}
+
+export interface VpcOptions {
+    
+    Ipv6Support?: boolean;
+}
+export declare namespace VpcOptions {
+    
+    const filterSensitiveLog: (obj: VpcOptions) => any;
+}
+export interface CreateVpcAttachmentRequest {
+    
+    CoreNetworkId: string | undefined;
+    
+    VpcArn: string | undefined;
+    
+    SubnetArns: string[] | undefined;
+    
+    Options?: VpcOptions;
+    
+    Tags?: Tag[];
+    
+    ClientToken?: string;
+}
+export declare namespace CreateVpcAttachmentRequest {
+    
+    const filterSensitiveLog: (obj: CreateVpcAttachmentRequest) => any;
+}
+
+export interface VpcAttachment {
+    
+    Attachment?: Attachment;
+    
+    SubnetArns?: string[];
+    
+    Options?: VpcOptions;
+}
+export declare namespace VpcAttachment {
+    
+    const filterSensitiveLog: (obj: VpcAttachment) => any;
+}
+export interface CreateVpcAttachmentResponse {
+    
+    VpcAttachment?: VpcAttachment;
+}
+export declare namespace CreateVpcAttachmentResponse {
+    
+    const filterSensitiveLog: (obj: CreateVpcAttachmentResponse) => any;
+}
+export interface DeleteAttachmentRequest {
+    
+    AttachmentId: string | undefined;
+}
+export declare namespace DeleteAttachmentRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAttachmentRequest) => any;
+}
+export interface DeleteAttachmentResponse {
+    
+    Attachment?: Attachment;
+}
+export declare namespace DeleteAttachmentResponse {
+    
+    const filterSensitiveLog: (obj: DeleteAttachmentResponse) => any;
+}
+export interface DeleteConnectionRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    ConnectionId: string | undefined;
+}
+export declare namespace DeleteConnectionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteConnectionRequest) => any;
+}
+export interface DeleteConnectionResponse {
+    
+    Connection?: Connection;
+}
+export declare namespace DeleteConnectionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteConnectionResponse) => any;
+}
+export interface DeleteConnectPeerRequest {
+    
+    ConnectPeerId: string | undefined;
+}
+export declare namespace DeleteConnectPeerRequest {
+    
+    const filterSensitiveLog: (obj: DeleteConnectPeerRequest) => any;
+}
+export interface DeleteConnectPeerResponse {
+    
+    ConnectPeer?: ConnectPeer;
+}
+export declare namespace DeleteConnectPeerResponse {
+    
+    const filterSensitiveLog: (obj: DeleteConnectPeerResponse) => any;
+}
+export interface DeleteCoreNetworkRequest {
+    
+    CoreNetworkId: string | undefined;
+}
+export declare namespace DeleteCoreNetworkRequest {
+    
+    const filterSensitiveLog: (obj: DeleteCoreNetworkRequest) => any;
+}
+export interface DeleteCoreNetworkResponse {
+    
+    CoreNetwork?: CoreNetwork;
+}
+export declare namespace DeleteCoreNetworkResponse {
+    
+    const filterSensitiveLog: (obj: DeleteCoreNetworkResponse) => any;
+}
+export interface DeleteCoreNetworkPolicyVersionRequest {
+    
+    CoreNetworkId: string | undefined;
+    
+    PolicyVersionId: number | undefined;
+}
+export declare namespace DeleteCoreNetworkPolicyVersionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteCoreNetworkPolicyVersionRequest) => any;
+}
+export interface DeleteCoreNetworkPolicyVersionResponse {
+    
+    CoreNetworkPolicy?: CoreNetworkPolicy;
+}
+export declare namespace DeleteCoreNetworkPolicyVersionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteCoreNetworkPolicyVersionResponse) => any;
+}
+export interface DeleteDeviceRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    DeviceId: string | undefined;
+}
+export declare namespace DeleteDeviceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDeviceRequest) => any;
+}
+export interface DeleteDeviceResponse {
+    
+    Device?: Device;
+}
+export declare namespace DeleteDeviceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDeviceResponse) => any;
+}
+export interface DeleteGlobalNetworkRequest {
+    
+    GlobalNetworkId: string | undefined;
+}
+export declare namespace DeleteGlobalNetworkRequest {
+    
+    const filterSensitiveLog: (obj: DeleteGlobalNetworkRequest) => any;
+}
+export interface DeleteGlobalNetworkResponse {
+    
+    GlobalNetwork?: GlobalNetwork;
+}
+export declare namespace DeleteGlobalNetworkResponse {
+    
+    const filterSensitiveLog: (obj: DeleteGlobalNetworkResponse) => any;
+}
+export interface DeleteLinkRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    LinkId: string | undefined;
+}
+export declare namespace DeleteLinkRequest {
+    
+    const filterSensitiveLog: (obj: DeleteLinkRequest) => any;
+}
+export interface DeleteLinkResponse {
+    
+    Link?: Link;
+}
+export declare namespace DeleteLinkResponse {
+    
+    const filterSensitiveLog: (obj: DeleteLinkResponse) => any;
+}
+export interface DeleteResourcePolicyRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace DeleteResourcePolicyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteResourcePolicyRequest) => any;
+}
+export interface DeleteResourcePolicyResponse {
+}
+export declare namespace DeleteResourcePolicyResponse {
+    
+    const filterSensitiveLog: (obj: DeleteResourcePolicyResponse) => any;
+}
+export interface DeleteSiteRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    SiteId: string | undefined;
+}
+export declare namespace DeleteSiteRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSiteRequest) => any;
+}
+export interface DeleteSiteResponse {
+    
+    Site?: Site;
+}
+export declare namespace DeleteSiteResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSiteResponse) => any;
+}
+export interface DeregisterTransitGatewayRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    TransitGatewayArn: string | undefined;
+}
+export declare namespace DeregisterTransitGatewayRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterTransitGatewayRequest) => any;
+}
+export declare enum TransitGatewayRegistrationState {
+    available = "AVAILABLE",
+    deleted = "DELETED",
+    deleting = "DELETING",
+    failed = "FAILED",
+    pending = "PENDING"
+}
+
+export interface TransitGatewayRegistrationStateReason {
+    
+    Code?: TransitGatewayRegistrationState | string;
+    
+    Message?: string;
+}
+export declare namespace TransitGatewayRegistrationStateReason {
+    
+    const filterSensitiveLog: (obj: TransitGatewayRegistrationStateReason) => any;
+}
+
+export interface TransitGatewayRegistration {
+    
+    GlobalNetworkId?: string;
+    
+    TransitGatewayArn?: string;
+    
+    State?: TransitGatewayRegistrationStateReason;
+}
+export declare namespace TransitGatewayRegistration {
+    
+    const filterSensitiveLog: (obj: TransitGatewayRegistration) => any;
+}
+export interface DeregisterTransitGatewayResponse {
+    
+    TransitGatewayRegistration?: TransitGatewayRegistration;
+}
+export declare namespace DeregisterTransitGatewayResponse {
+    
+    const filterSensitiveLog: (obj: DeregisterTransitGatewayResponse) => any;
+}
+export interface DescribeGlobalNetworksRequest {
+    
+    GlobalNetworkIds?: string[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeGlobalNetworksRequest {
+    
+    const filterSensitiveLog: (obj: DescribeGlobalNetworksRequest) => any;
+}
+export interface DescribeGlobalNetworksResponse {
+    
+    GlobalNetworks?: GlobalNetwork[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeGlobalNetworksResponse {
+    
+    const filterSensitiveLog: (obj: DescribeGlobalNetworksResponse) => any;
+}
+export interface DisassociateConnectPeerRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    ConnectPeerId: string | undefined;
+}
+export declare namespace DisassociateConnectPeerRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateConnectPeerRequest) => any;
+}
+export interface DisassociateConnectPeerResponse {
+    
+    ConnectPeerAssociation?: ConnectPeerAssociation;
+}
+export declare namespace DisassociateConnectPeerResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateConnectPeerResponse) => any;
+}
+export interface DisassociateCustomerGatewayRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    CustomerGatewayArn: string | undefined;
+}
+export declare namespace DisassociateCustomerGatewayRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateCustomerGatewayRequest) => any;
+}
+export interface DisassociateCustomerGatewayResponse {
+    
+    CustomerGatewayAssociation?: CustomerGatewayAssociation;
+}
+export declare namespace DisassociateCustomerGatewayResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateCustomerGatewayResponse) => any;
+}
+export interface DisassociateLinkRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    DeviceId: string | undefined;
+    
+    LinkId: string | undefined;
+}
+export declare namespace DisassociateLinkRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateLinkRequest) => any;
+}
+export interface DisassociateLinkResponse {
+    
+    LinkAssociation?: LinkAssociation;
+}
+export declare namespace DisassociateLinkResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateLinkResponse) => any;
+}
+export interface DisassociateTransitGatewayConnectPeerRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    TransitGatewayConnectPeerArn: string | undefined;
+}
+export declare namespace DisassociateTransitGatewayConnectPeerRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateTransitGatewayConnectPeerRequest) => any;
+}
+export interface DisassociateTransitGatewayConnectPeerResponse {
+    
+    TransitGatewayConnectPeerAssociation?: TransitGatewayConnectPeerAssociation;
+}
+export declare namespace DisassociateTransitGatewayConnectPeerResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateTransitGatewayConnectPeerResponse) => any;
+}
+export interface ExecuteCoreNetworkChangeSetRequest {
+    
+    CoreNetworkId: string | undefined;
+    
+    PolicyVersionId: number | undefined;
+}
+export declare namespace ExecuteCoreNetworkChangeSetRequest {
+    
+    const filterSensitiveLog: (obj: ExecuteCoreNetworkChangeSetRequest) => any;
+}
+export interface ExecuteCoreNetworkChangeSetResponse {
+}
+export declare namespace ExecuteCoreNetworkChangeSetResponse {
+    
+    const filterSensitiveLog: (obj: ExecuteCoreNetworkChangeSetResponse) => any;
+}
+export interface GetConnectAttachmentRequest {
+    
+    AttachmentId: string | undefined;
+}
+export declare namespace GetConnectAttachmentRequest {
+    
+    const filterSensitiveLog: (obj: GetConnectAttachmentRequest) => any;
+}
+export interface GetConnectAttachmentResponse {
+    
+    ConnectAttachment?: ConnectAttachment;
+}
+export declare namespace GetConnectAttachmentResponse {
+    
+    const filterSensitiveLog: (obj: GetConnectAttachmentResponse) => any;
+}
+export interface GetConnectionsRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    ConnectionIds?: string[];
+    
+    DeviceId?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetConnectionsRequest {
+    
+    const filterSensitiveLog: (obj: GetConnectionsRequest) => any;
+}
+export interface GetConnectionsResponse {
+    
+    Connections?: Connection[];
+    
+    NextToken?: string;
+}
+export declare namespace GetConnectionsResponse {
+    
+    const filterSensitiveLog: (obj: GetConnectionsResponse) => any;
+}
+export interface GetConnectPeerRequest {
+    
+    ConnectPeerId: string | undefined;
+}
+export declare namespace GetConnectPeerRequest {
+    
+    const filterSensitiveLog: (obj: GetConnectPeerRequest) => any;
+}
+export interface GetConnectPeerResponse {
+    
+    ConnectPeer?: ConnectPeer;
+}
+export declare namespace GetConnectPeerResponse {
+    
+    const filterSensitiveLog: (obj: GetConnectPeerResponse) => any;
+}
+export interface GetConnectPeerAssociationsRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    ConnectPeerIds?: string[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetConnectPeerAssociationsRequest {
+    
+    const filterSensitiveLog: (obj: GetConnectPeerAssociationsRequest) => any;
+}
+export interface GetConnectPeerAssociationsResponse {
+    
+    ConnectPeerAssociations?: ConnectPeerAssociation[];
+    
+    NextToken?: string;
+}
+export declare namespace GetConnectPeerAssociationsResponse {
+    
+    const filterSensitiveLog: (obj: GetConnectPeerAssociationsResponse) => any;
+}
+export interface GetCoreNetworkRequest {
+    
+    CoreNetworkId: string | undefined;
+}
+export declare namespace GetCoreNetworkRequest {
+    
+    const filterSensitiveLog: (obj: GetCoreNetworkRequest) => any;
+}
+export interface GetCoreNetworkResponse {
+    
+    CoreNetwork?: CoreNetwork;
+}
+export declare namespace GetCoreNetworkResponse {
+    
+    const filterSensitiveLog: (obj: GetCoreNetworkResponse) => any;
+}
+export interface GetCoreNetworkChangeSetRequest {
+    
+    CoreNetworkId: string | undefined;
+    
+    PolicyVersionId: number | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetCoreNetworkChangeSetRequest {
+    
+    const filterSensitiveLog: (obj: GetCoreNetworkChangeSetRequest) => any;
+}
+export interface GetCoreNetworkChangeSetResponse {
+    
+    CoreNetworkChanges?: CoreNetworkChange[];
+    
+    NextToken?: string;
+}
+export declare namespace GetCoreNetworkChangeSetResponse {
+    
+    const filterSensitiveLog: (obj: GetCoreNetworkChangeSetResponse) => any;
+}
+export interface GetCoreNetworkPolicyRequest {
+    
+    CoreNetworkId: string | undefined;
+    
+    PolicyVersionId?: number;
+    
+    Alias?: CoreNetworkPolicyAlias | string;
+}
+export declare namespace GetCoreNetworkPolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetCoreNetworkPolicyRequest) => any;
+}
+export interface GetCoreNetworkPolicyResponse {
+    
+    CoreNetworkPolicy?: CoreNetworkPolicy;
+}
+export declare namespace GetCoreNetworkPolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetCoreNetworkPolicyResponse) => any;
+}
+export interface GetCustomerGatewayAssociationsRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    CustomerGatewayArns?: string[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetCustomerGatewayAssociationsRequest {
+    
+    const filterSensitiveLog: (obj: GetCustomerGatewayAssociationsRequest) => any;
+}
+export interface GetCustomerGatewayAssociationsResponse {
+    
+    CustomerGatewayAssociations?: CustomerGatewayAssociation[];
+    
+    NextToken?: string;
+}
+export declare namespace GetCustomerGatewayAssociationsResponse {
+    
+    const filterSensitiveLog: (obj: GetCustomerGatewayAssociationsResponse) => any;
+}
+export interface GetDevicesRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    DeviceIds?: string[];
+    
+    SiteId?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetDevicesRequest {
+    
+    const filterSensitiveLog: (obj: GetDevicesRequest) => any;
+}
+export interface GetDevicesResponse {
+    
+    Devices?: Device[];
+    
+    NextToken?: string;
+}
+export declare namespace GetDevicesResponse {
+    
+    const filterSensitiveLog: (obj: GetDevicesResponse) => any;
+}
+export interface GetLinkAssociationsRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    DeviceId?: string;
+    
+    LinkId?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetLinkAssociationsRequest {
+    
+    const filterSensitiveLog: (obj: GetLinkAssociationsRequest) => any;
+}
+export interface GetLinkAssociationsResponse {
+    
+    LinkAssociations?: LinkAssociation[];
+    
+    NextToken?: string;
+}
+export declare namespace GetLinkAssociationsResponse {
+    
+    const filterSensitiveLog: (obj: GetLinkAssociationsResponse) => any;
+}
+export interface GetLinksRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    LinkIds?: string[];
+    
+    SiteId?: string;
+    
+    Type?: string;
+    
+    Provider?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetLinksRequest {
+    
+    const filterSensitiveLog: (obj: GetLinksRequest) => any;
+}
+export interface GetLinksResponse {
+    
+    Links?: Link[];
+    
+    NextToken?: string;
+}
+export declare namespace GetLinksResponse {
+    
+    const filterSensitiveLog: (obj: GetLinksResponse) => any;
+}
+export interface GetNetworkResourceCountsRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    ResourceType?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetNetworkResourceCountsRequest {
+    
+    const filterSensitiveLog: (obj: GetNetworkResourceCountsRequest) => any;
+}
+
+export interface NetworkResourceCount {
+    
+    ResourceType?: string;
+    
+    Count?: number;
+}
+export declare namespace NetworkResourceCount {
+    
+    const filterSensitiveLog: (obj: NetworkResourceCount) => any;
+}
+export interface GetNetworkResourceCountsResponse {
+    
+    NetworkResourceCounts?: NetworkResourceCount[];
+    
+    NextToken?: string;
+}
+export declare namespace GetNetworkResourceCountsResponse {
+    
+    const filterSensitiveLog: (obj: GetNetworkResourceCountsResponse) => any;
+}
+export interface GetNetworkResourceRelationshipsRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    CoreNetworkId?: string;
+    
+    RegisteredGatewayArn?: string;
+    
+    AwsRegion?: string;
+    
+    AccountId?: string;
+    
+    ResourceType?: string;
+    
+    ResourceArn?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetNetworkResourceRelationshipsRequest {
+    
+    const filterSensitiveLog: (obj: GetNetworkResourceRelationshipsRequest) => any;
+}
+
+export interface Relationship {
+    
+    From?: string;
+    
+    To?: string;
+}
+export declare namespace Relationship {
+    
+    const filterSensitiveLog: (obj: Relationship) => any;
+}
+export interface GetNetworkResourceRelationshipsResponse {
+    
+    Relationships?: Relationship[];
+    
+    NextToken?: string;
+}
+export declare namespace GetNetworkResourceRelationshipsResponse {
+    
+    const filterSensitiveLog: (obj: GetNetworkResourceRelationshipsResponse) => any;
+}
+export interface GetNetworkResourcesRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    CoreNetworkId?: string;
+    
+    RegisteredGatewayArn?: string;
+    
+    AwsRegion?: string;
+    
+    AccountId?: string;
+    
+    ResourceType?: string;
+    
+    ResourceArn?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetNetworkResourcesRequest {
+    
+    const filterSensitiveLog: (obj: GetNetworkResourcesRequest) => any;
+}
+
+export interface NetworkResource {
+    
+    RegisteredGatewayArn?: string;
+    
+    CoreNetworkId?: string;
+    
+    AwsRegion?: string;
+    
+    AccountId?: string;
+    
+    ResourceType?: string;
+    
+    ResourceId?: string;
+    
+    ResourceArn?: string;
+    
+    Definition?: string;
+    
+    DefinitionTimestamp?: Date;
+    
+    Tags?: Tag[];
+    
+    Metadata?: {
+        [key: string]: string;
+    };
+}
+export declare namespace NetworkResource {
+    
+    const filterSensitiveLog: (obj: NetworkResource) => any;
+}
+export interface GetNetworkResourcesResponse {
+    
+    NetworkResources?: NetworkResource[];
+    
+    NextToken?: string;
+}
+export declare namespace GetNetworkResourcesResponse {
+    
+    const filterSensitiveLog: (obj: GetNetworkResourcesResponse) => any;
+}
+
+export interface RouteTableIdentifier {
+    
+    TransitGatewayRouteTableArn?: string;
+    
+    CoreNetworkSegmentEdge?: CoreNetworkSegmentEdgeIdentifier;
+}
+export declare namespace RouteTableIdentifier {
+    
+    const filterSensitiveLog: (obj: RouteTableIdentifier) => any;
+}
+export declare enum RouteState {
+    ACTIVE = "ACTIVE",
+    BLACKHOLE = "BLACKHOLE"
+}
+export declare enum RouteType {
+    PROPAGATED = "PROPAGATED",
+    STATIC = "STATIC"
+}
+export interface GetNetworkRoutesRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    RouteTableIdentifier: RouteTableIdentifier | undefined;
+    
+    ExactCidrMatches?: string[];
+    
+    LongestPrefixMatches?: string[];
+    
+    SubnetOfMatches?: string[];
+    
+    SupernetOfMatches?: string[];
+    
+    PrefixListIds?: string[];
+    
+    States?: (RouteState | string)[];
+    
+    Types?: (RouteType | string)[];
+    
+    DestinationFilters?: {
+        [key: string]: string[];
+    };
+}
+export declare namespace GetNetworkRoutesRequest {
+    
+    const filterSensitiveLog: (obj: GetNetworkRoutesRequest) => any;
+}
+
+export interface NetworkRouteDestination {
+    
+    CoreNetworkAttachmentId?: string;
+    
+    TransitGatewayAttachmentId?: string;
+    
+    SegmentName?: string;
+    
+    EdgeLocation?: string;
+    
+    ResourceType?: string;
+    
+    ResourceId?: string;
+}
+export declare namespace NetworkRouteDestination {
+    
+    const filterSensitiveLog: (obj: NetworkRouteDestination) => any;
+}
+
+export interface NetworkRoute {
+    
+    DestinationCidrBlock?: string;
+    
+    Destinations?: NetworkRouteDestination[];
+    
+    PrefixListId?: string;
+    
+    State?: RouteState | string;
+    
+    Type?: RouteType | string;
+}
+export declare namespace NetworkRoute {
+    
+    const filterSensitiveLog: (obj: NetworkRoute) => any;
+}
+export declare enum RouteTableType {
+    CORE_NETWORK_SEGMENT = "CORE_NETWORK_SEGMENT",
+    TRANSIT_GATEWAY_ROUTE_TABLE = "TRANSIT_GATEWAY_ROUTE_TABLE"
+}
+export interface GetNetworkRoutesResponse {
+    
+    RouteTableArn?: string;
+    
+    CoreNetworkSegmentEdge?: CoreNetworkSegmentEdgeIdentifier;
+    
+    RouteTableType?: RouteTableType | string;
+    
+    RouteTableTimestamp?: Date;
+    
+    NetworkRoutes?: NetworkRoute[];
+}
+export declare namespace GetNetworkRoutesResponse {
+    
+    const filterSensitiveLog: (obj: GetNetworkRoutesResponse) => any;
+}
+export interface GetNetworkTelemetryRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    CoreNetworkId?: string;
+    
+    RegisteredGatewayArn?: string;
+    
+    AwsRegion?: string;
+    
+    AccountId?: string;
+    
+    ResourceType?: string;
+    
+    ResourceArn?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetNetworkTelemetryRequest {
+    
+    const filterSensitiveLog: (obj: GetNetworkTelemetryRequest) => any;
+}
+
+export interface NetworkTelemetry {
+    
+    RegisteredGatewayArn?: string;
+    
+    CoreNetworkId?: string;
+    
+    AwsRegion?: string;
+    
+    AccountId?: string;
+    
+    ResourceType?: string;
+    
+    ResourceId?: string;
+    
+    ResourceArn?: string;
+    
+    Address?: string;
+    
+    Health?: ConnectionHealth;
+}
+export declare namespace NetworkTelemetry {
+    
+    const filterSensitiveLog: (obj: NetworkTelemetry) => any;
+}
+export interface GetNetworkTelemetryResponse {
+    
+    NetworkTelemetry?: NetworkTelemetry[];
+    
+    NextToken?: string;
+}
+export declare namespace GetNetworkTelemetryResponse {
+    
+    const filterSensitiveLog: (obj: GetNetworkTelemetryResponse) => any;
+}
+export interface GetResourcePolicyRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace GetResourcePolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetResourcePolicyRequest) => any;
+}
+export interface GetResourcePolicyResponse {
+    
+    PolicyDocument?: __LazyJsonString | string;
+}
+export declare namespace GetResourcePolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetResourcePolicyResponse) => any;
+}
+export interface GetRouteAnalysisRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    RouteAnalysisId: string | undefined;
+}
+export declare namespace GetRouteAnalysisRequest {
+    
+    const filterSensitiveLog: (obj: GetRouteAnalysisRequest) => any;
+}
+
+export interface RouteAnalysisEndpointOptions {
+    
+    TransitGatewayAttachmentArn?: string;
+    
+    TransitGatewayArn?: string;
+    
+    IpAddress?: string;
+}
+export declare namespace RouteAnalysisEndpointOptions {
+    
+    const filterSensitiveLog: (obj: RouteAnalysisEndpointOptions) => any;
+}
+export declare enum RouteAnalysisCompletionReasonCode {
+    BLACKHOLE_ROUTE_FOR_DESTINATION_FOUND = "BLACKHOLE_ROUTE_FOR_DESTINATION_FOUND",
+    CYCLIC_PATH_DETECTED = "CYCLIC_PATH_DETECTED",
+    INACTIVE_ROUTE_FOR_DESTINATION_FOUND = "INACTIVE_ROUTE_FOR_DESTINATION_FOUND",
+    MAX_HOPS_EXCEEDED = "MAX_HOPS_EXCEEDED",
+    NO_DESTINATION_ARN_PROVIDED = "NO_DESTINATION_ARN_PROVIDED",
+    POSSIBLE_MIDDLEBOX = "POSSIBLE_MIDDLEBOX",
+    ROUTE_NOT_FOUND = "ROUTE_NOT_FOUND",
+    TRANSIT_GATEWAY_ATTACHMENT = "TRANSIT_GATEWAY_ATTACHMENT_ATTACH_ARN_NO_MATCH",
+    TRANSIT_GATEWAY_ATTACHMENT_NOT_FOUND = "TRANSIT_GATEWAY_ATTACHMENT_NOT_FOUND",
+    TRANSIT_GATEWAY_ATTACHMENT_NOT_IN_TRANSIT_GATEWAY = "TRANSIT_GATEWAY_ATTACHMENT_NOT_IN_TRANSIT_GATEWAY",
+    TRANSIT_GATEWAY_ATTACHMENT_STABLE_ROUTE_TABLE_NOT_FOUND = "TRANSIT_GATEWAY_ATTACHMENT_STABLE_ROUTE_TABLE_NOT_FOUND"
+}
+export declare enum RouteAnalysisCompletionResultCode {
+    CONNECTED = "CONNECTED",
+    NOT_CONNECTED = "NOT_CONNECTED"
+}
+
+export interface RouteAnalysisCompletion {
+    
+    ResultCode?: RouteAnalysisCompletionResultCode | string;
+    
+    ReasonCode?: RouteAnalysisCompletionReasonCode | string;
+    
+    ReasonContext?: {
+        [key: string]: string;
+    };
+}
+export declare namespace RouteAnalysisCompletion {
+    
+    const filterSensitiveLog: (obj: RouteAnalysisCompletion) => any;
+}
+
+export interface NetworkResourceSummary {
+    
+    RegisteredGatewayArn?: string;
+    
+    ResourceArn?: string;
+    
+    ResourceType?: string;
+    
+    Definition?: string;
+    
+    NameTag?: string;
+    
+    IsMiddlebox?: boolean;
+}
+export declare namespace NetworkResourceSummary {
+    
+    const filterSensitiveLog: (obj: NetworkResourceSummary) => any;
+}
+
+export interface PathComponent {
+    
+    Sequence?: number;
+    
+    Resource?: NetworkResourceSummary;
+    
+    DestinationCidrBlock?: string;
+}
+export declare namespace PathComponent {
+    
+    const filterSensitiveLog: (obj: PathComponent) => any;
+}
+
+export interface RouteAnalysisPath {
+    
+    CompletionStatus?: RouteAnalysisCompletion;
+    
+    Path?: PathComponent[];
+}
+export declare namespace RouteAnalysisPath {
+    
+    const filterSensitiveLog: (obj: RouteAnalysisPath) => any;
+}
+export declare enum RouteAnalysisStatus {
+    completed = "COMPLETED",
+    failed = "FAILED",
+    running = "RUNNING"
+}
+
+export interface RouteAnalysis {
+    
+    GlobalNetworkId?: string;
+    
+    OwnerAccountId?: string;
+    
+    RouteAnalysisId?: string;
+    
+    StartTimestamp?: Date;
+    
+    Status?: RouteAnalysisStatus | string;
+    
+    Source?: RouteAnalysisEndpointOptions;
+    
+    Destination?: RouteAnalysisEndpointOptions;
+    
+    IncludeReturnPath?: boolean;
+    
+    UseMiddleboxes?: boolean;
+    
+    ForwardPath?: RouteAnalysisPath;
+    
+    ReturnPath?: RouteAnalysisPath;
+}
+export declare namespace RouteAnalysis {
+    
+    const filterSensitiveLog: (obj: RouteAnalysis) => any;
+}
+export interface GetRouteAnalysisResponse {
+    
+    RouteAnalysis?: RouteAnalysis;
+}
+export declare namespace GetRouteAnalysisResponse {
+    
+    const filterSensitiveLog: (obj: GetRouteAnalysisResponse) => any;
+}
+export interface GetSitesRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    SiteIds?: string[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetSitesRequest {
+    
+    const filterSensitiveLog: (obj: GetSitesRequest) => any;
+}
+export interface GetSitesResponse {
+    
+    Sites?: Site[];
+    
+    NextToken?: string;
+}
+export declare namespace GetSitesResponse {
+    
+    const filterSensitiveLog: (obj: GetSitesResponse) => any;
+}
+export interface GetSiteToSiteVpnAttachmentRequest {
+    
+    AttachmentId: string | undefined;
+}
+export declare namespace GetSiteToSiteVpnAttachmentRequest {
+    
+    const filterSensitiveLog: (obj: GetSiteToSiteVpnAttachmentRequest) => any;
+}
+export interface GetSiteToSiteVpnAttachmentResponse {
+    
+    SiteToSiteVpnAttachment?: SiteToSiteVpnAttachment;
+}
+export declare namespace GetSiteToSiteVpnAttachmentResponse {
+    
+    const filterSensitiveLog: (obj: GetSiteToSiteVpnAttachmentResponse) => any;
+}
+export interface GetTransitGatewayConnectPeerAssociationsRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    TransitGatewayConnectPeerArns?: string[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetTransitGatewayConnectPeerAssociationsRequest {
+    
+    const filterSensitiveLog: (obj: GetTransitGatewayConnectPeerAssociationsRequest) => any;
+}
+export interface GetTransitGatewayConnectPeerAssociationsResponse {
+    
+    TransitGatewayConnectPeerAssociations?: TransitGatewayConnectPeerAssociation[];
+    
+    NextToken?: string;
+}
+export declare namespace GetTransitGatewayConnectPeerAssociationsResponse {
+    
+    const filterSensitiveLog: (obj: GetTransitGatewayConnectPeerAssociationsResponse) => any;
+}
+export interface GetTransitGatewayRegistrationsRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    TransitGatewayArns?: string[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetTransitGatewayRegistrationsRequest {
+    
+    const filterSensitiveLog: (obj: GetTransitGatewayRegistrationsRequest) => any;
+}
+export interface GetTransitGatewayRegistrationsResponse {
+    
+    TransitGatewayRegistrations?: TransitGatewayRegistration[];
+    
+    NextToken?: string;
+}
+export declare namespace GetTransitGatewayRegistrationsResponse {
+    
+    const filterSensitiveLog: (obj: GetTransitGatewayRegistrationsResponse) => any;
+}
+export interface GetVpcAttachmentRequest {
+    
+    AttachmentId: string | undefined;
+}
+export declare namespace GetVpcAttachmentRequest {
+    
+    const filterSensitiveLog: (obj: GetVpcAttachmentRequest) => any;
+}
+export interface GetVpcAttachmentResponse {
+    
+    VpcAttachment?: VpcAttachment;
+}
+export declare namespace GetVpcAttachmentResponse {
+    
+    const filterSensitiveLog: (obj: GetVpcAttachmentResponse) => any;
+}
+export interface ListAttachmentsRequest {
+    
+    CoreNetworkId?: string;
+    
+    AttachmentType?: AttachmentType | string;
+    
+    EdgeLocation?: string;
+    
+    State?: AttachmentState | string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListAttachmentsRequest {
+    
+    const filterSensitiveLog: (obj: ListAttachmentsRequest) => any;
+}
+export interface ListAttachmentsResponse {
+    
+    Attachments?: Attachment[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAttachmentsResponse {
+    
+    const filterSensitiveLog: (obj: ListAttachmentsResponse) => any;
+}
+export interface ListConnectPeersRequest {
+    
+    CoreNetworkId?: string;
+    
+    ConnectAttachmentId?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListConnectPeersRequest {
+    
+    const filterSensitiveLog: (obj: ListConnectPeersRequest) => any;
+}
+export interface ListConnectPeersResponse {
+    
+    ConnectPeers?: ConnectPeerSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListConnectPeersResponse {
+    
+    const filterSensitiveLog: (obj: ListConnectPeersResponse) => any;
+}
+export interface ListCoreNetworkPolicyVersionsRequest {
+    
+    CoreNetworkId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListCoreNetworkPolicyVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListCoreNetworkPolicyVersionsRequest) => any;
+}
+export interface ListCoreNetworkPolicyVersionsResponse {
+    
+    CoreNetworkPolicyVersions?: CoreNetworkPolicyVersion[];
+    
+    NextToken?: string;
+}
+export declare namespace ListCoreNetworkPolicyVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListCoreNetworkPolicyVersionsResponse) => any;
+}
+export interface ListCoreNetworksRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListCoreNetworksRequest {
+    
+    const filterSensitiveLog: (obj: ListCoreNetworksRequest) => any;
+}
+export interface ListCoreNetworksResponse {
+    
+    CoreNetworks?: CoreNetworkSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListCoreNetworksResponse {
+    
+    const filterSensitiveLog: (obj: ListCoreNetworksResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    TagList?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface PutCoreNetworkPolicyRequest {
+    
+    CoreNetworkId: string | undefined;
+    
+    PolicyDocument: __LazyJsonString | string | undefined;
+    
+    Description?: string;
+    
+    LatestVersionId?: number;
+    
+    ClientToken?: string;
+}
+export declare namespace PutCoreNetworkPolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutCoreNetworkPolicyRequest) => any;
+}
+export interface PutCoreNetworkPolicyResponse {
+    
+    CoreNetworkPolicy?: CoreNetworkPolicy;
+}
+export declare namespace PutCoreNetworkPolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutCoreNetworkPolicyResponse) => any;
+}
+export interface PutResourcePolicyRequest {
+    
+    PolicyDocument: __LazyJsonString | string | undefined;
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace PutResourcePolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutResourcePolicyRequest) => any;
+}
+export interface PutResourcePolicyResponse {
+}
+export declare namespace PutResourcePolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutResourcePolicyResponse) => any;
+}
+export interface RegisterTransitGatewayRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    TransitGatewayArn: string | undefined;
+}
+export declare namespace RegisterTransitGatewayRequest {
+    
+    const filterSensitiveLog: (obj: RegisterTransitGatewayRequest) => any;
+}
+export interface RegisterTransitGatewayResponse {
+    
+    TransitGatewayRegistration?: TransitGatewayRegistration;
+}
+export declare namespace RegisterTransitGatewayResponse {
+    
+    const filterSensitiveLog: (obj: RegisterTransitGatewayResponse) => any;
+}
+export interface RejectAttachmentRequest {
+    
+    AttachmentId: string | undefined;
+}
+export declare namespace RejectAttachmentRequest {
+    
+    const filterSensitiveLog: (obj: RejectAttachmentRequest) => any;
+}
+export interface RejectAttachmentResponse {
+    
+    Attachment?: Attachment;
+}
+export declare namespace RejectAttachmentResponse {
+    
+    const filterSensitiveLog: (obj: RejectAttachmentResponse) => any;
+}
+export interface RestoreCoreNetworkPolicyVersionRequest {
+    
+    CoreNetworkId: string | undefined;
+    
+    PolicyVersionId: number | undefined;
+}
+export declare namespace RestoreCoreNetworkPolicyVersionRequest {
+    
+    const filterSensitiveLog: (obj: RestoreCoreNetworkPolicyVersionRequest) => any;
+}
+export interface RestoreCoreNetworkPolicyVersionResponse {
+    
+    CoreNetworkPolicy?: CoreNetworkPolicy;
+}
+export declare namespace RestoreCoreNetworkPolicyVersionResponse {
+    
+    const filterSensitiveLog: (obj: RestoreCoreNetworkPolicyVersionResponse) => any;
+}
+
+export interface RouteAnalysisEndpointOptionsSpecification {
+    
+    TransitGatewayAttachmentArn?: string;
+    
+    IpAddress?: string;
+}
+export declare namespace RouteAnalysisEndpointOptionsSpecification {
+    
+    const filterSensitiveLog: (obj: RouteAnalysisEndpointOptionsSpecification) => any;
+}
+export interface StartRouteAnalysisRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    Source: RouteAnalysisEndpointOptionsSpecification | undefined;
+    
+    Destination: RouteAnalysisEndpointOptionsSpecification | undefined;
+    
+    IncludeReturnPath?: boolean;
+    
+    UseMiddleboxes?: boolean;
+}
+export declare namespace StartRouteAnalysisRequest {
+    
+    const filterSensitiveLog: (obj: StartRouteAnalysisRequest) => any;
+}
+export interface StartRouteAnalysisResponse {
+    
+    RouteAnalysis?: RouteAnalysis;
+}
+export declare namespace StartRouteAnalysisResponse {
+    
+    const filterSensitiveLog: (obj: StartRouteAnalysisResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateConnectionRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    ConnectionId: string | undefined;
+    
+    LinkId?: string;
+    
+    ConnectedLinkId?: string;
+    
+    Description?: string;
+}
+export declare namespace UpdateConnectionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateConnectionRequest) => any;
+}
+export interface UpdateConnectionResponse {
+    
+    Connection?: Connection;
+}
+export declare namespace UpdateConnectionResponse {
+    
+    const filterSensitiveLog: (obj: UpdateConnectionResponse) => any;
+}
+export interface UpdateCoreNetworkRequest {
+    
+    CoreNetworkId: string | undefined;
+    
+    Description?: string;
+}
+export declare namespace UpdateCoreNetworkRequest {
+    
+    const filterSensitiveLog: (obj: UpdateCoreNetworkRequest) => any;
+}
+export interface UpdateCoreNetworkResponse {
+    
+    CoreNetwork?: CoreNetwork;
+}
+export declare namespace UpdateCoreNetworkResponse {
+    
+    const filterSensitiveLog: (obj: UpdateCoreNetworkResponse) => any;
+}
+export interface UpdateDeviceRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    DeviceId: string | undefined;
+    
+    AWSLocation?: AWSLocation;
+    
+    Description?: string;
+    
+    Type?: string;
+    
+    Vendor?: string;
+    
+    Model?: string;
+    
+    SerialNumber?: string;
+    
+    Location?: Location;
+    
+    SiteId?: string;
+}
+export declare namespace UpdateDeviceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDeviceRequest) => any;
+}
+export interface UpdateDeviceResponse {
+    
+    Device?: Device;
+}
+export declare namespace UpdateDeviceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateDeviceResponse) => any;
+}
+export interface UpdateGlobalNetworkRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    Description?: string;
+}
+export declare namespace UpdateGlobalNetworkRequest {
+    
+    const filterSensitiveLog: (obj: UpdateGlobalNetworkRequest) => any;
+}
+export interface UpdateGlobalNetworkResponse {
+    
+    GlobalNetwork?: GlobalNetwork;
+}
+export declare namespace UpdateGlobalNetworkResponse {
+    
+    const filterSensitiveLog: (obj: UpdateGlobalNetworkResponse) => any;
+}
+export interface UpdateLinkRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    LinkId: string | undefined;
+    
+    Description?: string;
+    
+    Type?: string;
+    
+    Bandwidth?: Bandwidth;
+    
+    Provider?: string;
+}
+export declare namespace UpdateLinkRequest {
+    
+    const filterSensitiveLog: (obj: UpdateLinkRequest) => any;
+}
+export interface UpdateLinkResponse {
+    
+    Link?: Link;
+}
+export declare namespace UpdateLinkResponse {
+    
+    const filterSensitiveLog: (obj: UpdateLinkResponse) => any;
+}
+export interface UpdateNetworkResourceMetadataRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    ResourceArn: string | undefined;
+    
+    Metadata: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace UpdateNetworkResourceMetadataRequest {
+    
+    const filterSensitiveLog: (obj: UpdateNetworkResourceMetadataRequest) => any;
+}
+export interface UpdateNetworkResourceMetadataResponse {
+    
+    ResourceArn?: string;
+    
+    Metadata?: {
+        [key: string]: string;
+    };
+}
+export declare namespace UpdateNetworkResourceMetadataResponse {
+    
+    const filterSensitiveLog: (obj: UpdateNetworkResourceMetadataResponse) => any;
+}
+export interface UpdateSiteRequest {
+    
+    GlobalNetworkId: string | undefined;
+    
+    SiteId: string | undefined;
+    
+    Description?: string;
+    
+    Location?: Location;
+}
+export declare namespace UpdateSiteRequest {
+    
+    const filterSensitiveLog: (obj: UpdateSiteRequest) => any;
+}
+export interface UpdateSiteResponse {
+    
+    Site?: Site;
+}
+export declare namespace UpdateSiteResponse {
+    
+    const filterSensitiveLog: (obj: UpdateSiteResponse) => any;
+}
+export interface UpdateVpcAttachmentRequest {
+    
+    AttachmentId: string | undefined;
+    
+    AddSubnetArns?: string[];
+    
+    RemoveSubnetArns?: string[];
+    
+    Options?: VpcOptions;
+}
+export declare namespace UpdateVpcAttachmentRequest {
+    
+    const filterSensitiveLog: (obj: UpdateVpcAttachmentRequest) => any;
+}
+export interface UpdateVpcAttachmentResponse {
+    
+    VpcAttachment?: VpcAttachment;
+}
+export declare namespace UpdateVpcAttachmentResponse {
+    
+    const filterSensitiveLog: (obj: UpdateVpcAttachmentResponse) => any;
+}