Module aws_sdk_networkmanager::types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that AWS Network Manager can respond with.

Structs

• AccountStatus

  Describes the current status of an account within an Amazon Web Services Organization, including service-linked roles (SLRs).

• Attachment

  Describes a core network attachment.

• AwsLocation

  Specifies a location in Amazon Web Services.

• Bandwidth

  Describes bandwidth information.

• BgpOptions

  Describes the BGP options.

• ConnectAttachment

  Describes a core network Connect attachment.

• ConnectAttachmentOptions

  Describes a core network Connect attachment options.

• ConnectPeer

  Describes a core network Connect peer.

• ConnectPeerAssociation

  Describes a core network Connect peer association.

• ConnectPeerBgpConfiguration

  Describes a core network BGP configuration.

• ConnectPeerConfiguration

  Describes a core network Connect peer configuration.

• ConnectPeerSummary

  Summary description of a Connect peer.

• Connection

  Describes a connection.

• ConnectionHealth

  Describes connection health.

• CoreNetwork

  Describes a core network.

• CoreNetworkChange

  Details describing a core network change.

• CoreNetworkChangeEvent

  Describes a core network change event. This can be a change to a segment, attachment, route, etc.

• CoreNetworkChangeEventValues

  Describes a core network change event.

• CoreNetworkChangeValues

  Describes a core network change.

• CoreNetworkEdge

  Describes a core network edge.

• CoreNetworkPolicy

  Describes a core network policy. You can have only one LIVE Core Policy.

• CoreNetworkPolicyError

  Provides details about an error in a core network policy.

• CoreNetworkPolicyVersion

  Describes a core network policy version.

• CoreNetworkSegment

  Describes a core network segment, which are dedicated routes. Only attachments within this segment can communicate with each other.

• CoreNetworkSegmentEdgeIdentifier

  Returns details about a core network edge.

• CoreNetworkSummary

  Returns summary information about a core network.

• CustomerGatewayAssociation

  Describes the association between a customer gateway, a device, and a link.

• Device

  Describes a device.

• GlobalNetwork

  Describes a global network. This is a single private network acting as a high-level container for your network objects, including an Amazon Web Services-managed Core Network.

• Link

  Describes a link.

• LinkAssociation

  Describes the association between a device and a link.

• Location

  Describes a location.

• NetworkResource

  Describes a network resource.

• NetworkResourceCount

  Describes a resource count.

• NetworkResourceSummary

  Describes a network resource.

• NetworkRoute

  Describes a network route.

• NetworkRouteDestination

  Describes the destination of a network route.

• NetworkTelemetry

  Describes the telemetry information for a resource.

• OrganizationStatus

  The status of an Amazon Web Services Organization and the accounts within that organization.

• PathComponent

  Describes a path component.

• Peering

  Describes a peering connection.

• ProposedSegmentChange

  Describes a proposed segment change. In some cases, the segment change must first be evaluated and accepted.

• Relationship

  Describes a resource relationship.

• RouteAnalysis

  Describes a route analysis.

• RouteAnalysisCompletion

  Describes the status of an analysis at completion.

• RouteAnalysisEndpointOptions

  Describes a source or a destination.

• RouteAnalysisEndpointOptionsSpecification

  Describes a source or a destination.

• RouteAnalysisPath

  Describes a route analysis path.

• RouteTableIdentifier

  Describes a route table.

• Site

  Describes a site.

• SiteToSiteVpnAttachment

  Creates a site-to-site VPN attachment.

• Tag

  Describes a tag.

• TransitGatewayConnectPeerAssociation

  Describes a transit gateway Connect peer association.

• TransitGatewayPeering

  Describes a transit gateway peering attachment.

• TransitGatewayRegistration

  Describes the registration of a transit gateway to a global network.

• TransitGatewayRegistrationStateReason

  Describes the status of a transit gateway registration.

• TransitGatewayRouteTableAttachment

  Describes a transit gateway route table attachment.

• ValidationExceptionField

  Describes a validation exception for a field.

• VpcAttachment

  Describes a VPC attachment.

• VpcOptions

  Describes the VPC options.

Enums

• AttachmentState
  When writing a match expression against AttachmentState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AttachmentType
  When writing a match expression against AttachmentType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ChangeAction
  When writing a match expression against ChangeAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ChangeSetState
  When writing a match expression against ChangeSetState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ChangeStatus
  When writing a match expression against ChangeStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ChangeType
  When writing a match expression against ChangeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ConnectPeerAssociationState
  When writing a match expression against ConnectPeerAssociationState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ConnectPeerState
  When writing a match expression against ConnectPeerState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ConnectionState
  When writing a match expression against ConnectionState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ConnectionStatus
  When writing a match expression against ConnectionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ConnectionType
  When writing a match expression against ConnectionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• CoreNetworkPolicyAlias
  When writing a match expression against CoreNetworkPolicyAlias, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• CoreNetworkState
  When writing a match expression against CoreNetworkState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• CustomerGatewayAssociationState
  When writing a match expression against CustomerGatewayAssociationState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DeviceState
  When writing a match expression against DeviceState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• GlobalNetworkState
  When writing a match expression against GlobalNetworkState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• LinkAssociationState
  When writing a match expression against LinkAssociationState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• LinkState
  When writing a match expression against LinkState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• PeeringState
  When writing a match expression against PeeringState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• PeeringType
  When writing a match expression against PeeringType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RouteAnalysisCompletionReasonCode
  When writing a match expression against RouteAnalysisCompletionReasonCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RouteAnalysisCompletionResultCode
  When writing a match expression against RouteAnalysisCompletionResultCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RouteAnalysisStatus
  When writing a match expression against RouteAnalysisStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RouteState
  When writing a match expression against RouteState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RouteTableType
  When writing a match expression against RouteTableType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RouteType
  When writing a match expression against RouteType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SiteState
  When writing a match expression against SiteState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• TransitGatewayConnectPeerAssociationState
  When writing a match expression against TransitGatewayConnectPeerAssociationState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• TransitGatewayRegistrationState
  When writing a match expression against TransitGatewayRegistrationState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• TunnelProtocol
  When writing a match expression against TunnelProtocol, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ValidationExceptionReason
  When writing a match expression against ValidationExceptionReason, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.