@aws-sdk/client-networkmanager 3.41.0 → 3.46.0

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

@@ -1,58 +1,105 @@
+import { LazyJsonString as __LazyJsonString } from "@aws-sdk/smithy-client";
 import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
-
-export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
-    name: "AccessDeniedException";
-    $fault: "client";
-    Message: string | undefined;
+export interface AcceptAttachmentRequest {
+    
+    AttachmentId: string | undefined;
 }
-export declare namespace AccessDeniedException {
+export declare namespace AcceptAttachmentRequest {
     
-    const filterSensitiveLog: (obj: AccessDeniedException) => any;
+    const filterSensitiveLog: (obj: AcceptAttachmentRequest) => any;
 }
-export interface AssociateCustomerGatewayRequest {
+export declare enum AttachmentType {
+    CONNECT = "CONNECT",
+    SITE_TO_SITE_VPN = "SITE_TO_SITE_VPN",
+    VPC = "VPC"
+}
+
+export interface Tag {
     
-    CustomerGatewayArn: string | undefined;
+    Key?: string;
     
-    GlobalNetworkId: string | undefined;
+    Value?: string;
+}
+export declare namespace Tag {
     
-    DeviceId: string | undefined;
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface ProposedSegmentChange {
     
-    LinkId?: string;
+    Tags?: Tag[];
+    
+    AttachmentPolicyRuleNumber?: number;
+    
+    SegmentName?: string;
 }
-export declare namespace AssociateCustomerGatewayRequest {
+export declare namespace ProposedSegmentChange {
     
-    const filterSensitiveLog: (obj: AssociateCustomerGatewayRequest) => any;
+    const filterSensitiveLog: (obj: ProposedSegmentChange) => any;
 }
-export declare enum CustomerGatewayAssociationState {
-    available = "AVAILABLE",
-    deleted = "DELETED",
-    deleting = "DELETING",
-    pending = "PENDING"
+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 CustomerGatewayAssociation {
+export interface Attachment {
     
-    CustomerGatewayArn?: string;
+    CoreNetworkId?: string;
     
-    GlobalNetworkId?: string;
+    CoreNetworkArn?: string;
     
-    DeviceId?: string;
+    AttachmentId?: string;
     
-    LinkId?: string;
+    OwnerAccountId?: string;
     
-    State?: CustomerGatewayAssociationState | 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 CustomerGatewayAssociation {
+export declare namespace Attachment {
     
-    const filterSensitiveLog: (obj: CustomerGatewayAssociation) => any;
+    const filterSensitiveLog: (obj: Attachment) => any;
 }
-export interface AssociateCustomerGatewayResponse {
+export interface AcceptAttachmentResponse {
     
-    CustomerGatewayAssociation?: CustomerGatewayAssociation;
+    Attachment?: Attachment;
 }
-export declare namespace AssociateCustomerGatewayResponse {
+export declare namespace AcceptAttachmentResponse {
     
-    const filterSensitiveLog: (obj: AssociateCustomerGatewayResponse) => any;
+    const filterSensitiveLog: (obj: AcceptAttachmentResponse) => any;
+}
+
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    Message: string | undefined;
+}
+export declare namespace AccessDeniedException {
+    
+    const filterSensitiveLog: (obj: AccessDeniedException) => any;
 }
 
 export interface ConflictException extends __SmithyException, $MetadataBearer {
@@ -89,6 +136,7 @@ export interface ResourceNotFoundException extends __SmithyException, $MetadataB
     ResourceId: string | undefined;
     
     ResourceType: string | undefined;
+    
     Context?: {
         [key: string]: string;
     };
@@ -98,25 +146,6 @@ export declare namespace ResourceNotFoundException {
     const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
 }
 
-export interface ServiceQuotaExceededException extends __SmithyException, $MetadataBearer {
-    name: "ServiceQuotaExceededException";
-    $fault: "client";
-    
-    Message: string | undefined;
-    
-    ResourceId?: string;
-    
-    ResourceType?: string;
-    
-    LimitCode: string | undefined;
-    
-    ServiceCode: string | undefined;
-}
-export declare namespace ServiceQuotaExceededException {
-    
-    const filterSensitiveLog: (obj: ServiceQuotaExceededException) => any;
-}
-
 export interface ThrottlingException extends __SmithyException, $MetadataBearer {
     name: "ThrottlingException";
     $fault: "client";
@@ -159,6 +188,115 @@ export declare namespace ValidationException {
     
     const filterSensitiveLog: (obj: ValidationException) => any;
 }
+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 interface ServiceQuotaExceededException extends __SmithyException, $MetadataBearer {
+    name: "ServiceQuotaExceededException";
+    $fault: "client";
+    
+    Message: string | undefined;
+    
+    ResourceId?: string;
+    
+    ResourceType?: string;
+    
+    LimitCode: string | undefined;
+    
+    ServiceCode: string | undefined;
+}
+export declare namespace ServiceQuotaExceededException {
+    
+    const filterSensitiveLog: (obj: ServiceQuotaExceededException) => any;
+}
+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;
@@ -267,22 +405,65 @@ export declare namespace Bandwidth {
     
     const filterSensitiveLog: (obj: Bandwidth) => any;
 }
-export declare enum ConnectionState {
-    available = "AVAILABLE",
-    deleting = "DELETING",
-    pending = "PENDING",
-    updating = "UPDATING"
+
+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 Tag {
+export interface ConnectAttachmentOptions {
     
-    Key?: string;
+    Protocol?: TunnelProtocol | string;
+}
+export declare namespace ConnectAttachmentOptions {
     
-    Value?: string;
+    const filterSensitiveLog: (obj: ConnectAttachmentOptions) => any;
 }
-export declare namespace Tag {
+
+export interface ConnectAttachment {
     
-    const filterSensitiveLog: (obj: Tag) => any;
+    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 {
@@ -334,6 +515,314 @@ 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 interface CoreNetworkPolicyException extends __SmithyException, $MetadataBearer {
+    name: "CoreNetworkPolicyException";
+    $fault: "client";
+    Message: string | undefined;
+    
+    Errors?: CoreNetworkPolicyError[];
+}
+export declare namespace CoreNetworkPolicyException {
+    
+    const filterSensitiveLog: (obj: CoreNetworkPolicyException) => any;
+}
+
+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;
@@ -362,6 +851,58 @@ 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 {
     
@@ -603,27 +1144,174 @@ export interface CreateSiteResponse {
     
     Site?: Site;
 }
-export declare namespace CreateSiteResponse {
+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: CreateSiteResponse) => any;
+    const filterSensitiveLog: (obj: DeleteCoreNetworkResponse) => any;
 }
-export interface DeleteConnectionRequest {
+export interface DeleteCoreNetworkPolicyVersionRequest {
     
-    GlobalNetworkId: string | undefined;
+    CoreNetworkId: string | undefined;
     
-    ConnectionId: string | undefined;
+    PolicyVersionId: number | undefined;
 }
-export declare namespace DeleteConnectionRequest {
+export declare namespace DeleteCoreNetworkPolicyVersionRequest {
     
-    const filterSensitiveLog: (obj: DeleteConnectionRequest) => any;
+    const filterSensitiveLog: (obj: DeleteCoreNetworkPolicyVersionRequest) => any;
 }
-export interface DeleteConnectionResponse {
+export interface DeleteCoreNetworkPolicyVersionResponse {
     
-    Connection?: Connection;
+    CoreNetworkPolicy?: CoreNetworkPolicy;
 }
-export declare namespace DeleteConnectionResponse {
+export declare namespace DeleteCoreNetworkPolicyVersionResponse {
     
-    const filterSensitiveLog: (obj: DeleteConnectionResponse) => any;
+    const filterSensitiveLog: (obj: DeleteCoreNetworkPolicyVersionResponse) => any;
 }
 export interface DeleteDeviceRequest {
     
@@ -677,6 +1365,20 @@ 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;
@@ -766,6 +1468,24 @@ 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;
@@ -822,6 +1542,38 @@ 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;
@@ -848,6 +1600,106 @@ 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;
@@ -993,6 +1845,8 @@ export interface GetNetworkResourceRelationshipsRequest {
     
     GlobalNetworkId: string | undefined;
     
+    CoreNetworkId?: string;
+    
     RegisteredGatewayArn?: string;
     
     AwsRegion?: string;
@@ -1036,6 +1890,8 @@ export interface GetNetworkResourcesRequest {
     
     GlobalNetworkId: string | undefined;
     
+    CoreNetworkId?: string;
+    
     RegisteredGatewayArn?: string;
     
     AwsRegion?: string;
@@ -1059,6 +1915,8 @@ export interface NetworkResource {
     
     RegisteredGatewayArn?: string;
     
+    CoreNetworkId?: string;
+    
     AwsRegion?: string;
     
     AccountId?: string;
@@ -1097,6 +1955,8 @@ export declare namespace GetNetworkResourcesResponse {
 export interface RouteTableIdentifier {
     
     TransitGatewayRouteTableArn?: string;
+    
+    CoreNetworkSegmentEdge?: CoreNetworkSegmentEdgeIdentifier;
 }
 export declare namespace RouteTableIdentifier {
     
@@ -1141,8 +2001,14 @@ export declare namespace GetNetworkRoutesRequest {
 
 export interface NetworkRouteDestination {
     
+    CoreNetworkAttachmentId?: string;
+    
     TransitGatewayAttachmentId?: string;
     
+    SegmentName?: string;
+    
+    EdgeLocation?: string;
+    
     ResourceType?: string;
     
     ResourceId?: string;
@@ -1169,12 +2035,15 @@ 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;
@@ -1189,6 +2058,8 @@ export interface GetNetworkTelemetryRequest {
     
     GlobalNetworkId: string | undefined;
     
+    CoreNetworkId?: string;
+    
     RegisteredGatewayArn?: string;
     
     AwsRegion?: string;
@@ -1212,6 +2083,8 @@ export interface NetworkTelemetry {
     
     RegisteredGatewayArn?: string;
     
+    CoreNetworkId?: string;
+    
     AwsRegion?: string;
     
     AccountId?: string;
@@ -1240,6 +2113,22 @@ 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;
@@ -1404,6 +2293,22 @@ 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;
@@ -1452,6 +2357,116 @@ 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;
@@ -1468,6 +2483,46 @@ 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;
@@ -1486,6 +2541,40 @@ 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 {
     
@@ -1577,6 +2666,24 @@ 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;
@@ -1703,3 +2810,25 @@ 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;
+}