pulumi-aws 7.14.0__py3-none-any.whl → 7.15.0__py3-none-any.whl

pulumi_aws/networkmanager/_inputs.py

@@ -45,16 +45,34 @@ __all__ = [
     'GetCoreNetworkPolicyDocumentAttachmentPolicyActionArgsDict',
     'GetCoreNetworkPolicyDocumentAttachmentPolicyConditionArgs',
     'GetCoreNetworkPolicyDocumentAttachmentPolicyConditionArgsDict',
+    'GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleArgs',
+    'GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleArgsDict',
+    'GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleActionArgs',
+    'GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleActionArgsDict',
+    'GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleConditionArgs',
+    'GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleConditionArgsDict',
     'GetCoreNetworkPolicyDocumentCoreNetworkConfigurationArgs',
     'GetCoreNetworkPolicyDocumentCoreNetworkConfigurationArgsDict',
     'GetCoreNetworkPolicyDocumentCoreNetworkConfigurationEdgeLocationArgs',
     'GetCoreNetworkPolicyDocumentCoreNetworkConfigurationEdgeLocationArgsDict',
     'GetCoreNetworkPolicyDocumentNetworkFunctionGroupArgs',
     'GetCoreNetworkPolicyDocumentNetworkFunctionGroupArgsDict',
+    'GetCoreNetworkPolicyDocumentRoutingPolicyArgs',
+    'GetCoreNetworkPolicyDocumentRoutingPolicyArgsDict',
+    'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleArgs',
+    'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleArgsDict',
+    'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionArgs',
+    'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionArgsDict',
+    'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionActionArgs',
+    'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionActionArgsDict',
+    'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionMatchConditionArgs',
+    'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionMatchConditionArgsDict',
     'GetCoreNetworkPolicyDocumentSegmentArgs',
     'GetCoreNetworkPolicyDocumentSegmentArgsDict',
     'GetCoreNetworkPolicyDocumentSegmentActionArgs',
     'GetCoreNetworkPolicyDocumentSegmentActionArgsDict',
+    'GetCoreNetworkPolicyDocumentSegmentActionEdgeLocationAssociationArgs',
+    'GetCoreNetworkPolicyDocumentSegmentActionEdgeLocationAssociationArgsDict',
     'GetCoreNetworkPolicyDocumentSegmentActionViaArgs',
     'GetCoreNetworkPolicyDocumentSegmentActionViaArgsDict',
     'GetCoreNetworkPolicyDocumentSegmentActionViaWithEdgeOverrideArgs',
@@ -99,9 +117,9 @@ class ConnectAttachmentOptionsArgs:
 
 if not MYPY:
     class ConnectPeerBgpOptionsArgsDict(TypedDict):
-        peer_asn: NotRequired[pulumi.Input[_builtins.int]]
+        peer_asn: NotRequired[pulumi.Input[_builtins.str]]
         """
-        Peer ASN.
+        Peer ASN. Supports 2-byte and 4-byte ASNs (1 to 4294967295).
         """
 elif False:
     ConnectPeerBgpOptionsArgsDict: TypeAlias = Mapping[str, Any]
@@ -109,23 +127,23 @@ elif False:
 @pulumi.input_type
 class ConnectPeerBgpOptionsArgs:
     def __init__(__self__, *,
-                 peer_asn: Optional[pulumi.Input[_builtins.int]] = None):
+                 peer_asn: Optional[pulumi.Input[_builtins.str]] = None):
         """
-        :param pulumi.Input[_builtins.int] peer_asn: Peer ASN.
+        :param pulumi.Input[_builtins.str] peer_asn: Peer ASN. Supports 2-byte and 4-byte ASNs (1 to 4294967295).
         """
         if peer_asn is not None:
             pulumi.set(__self__, "peer_asn", peer_asn)
 
     @_builtins.property
     @pulumi.getter(name="peerAsn")
-    def peer_asn(self) -> Optional[pulumi.Input[_builtins.int]]:
+    def peer_asn(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Peer ASN.
+        Peer ASN. Supports 2-byte and 4-byte ASNs (1 to 4294967295).
         """
         return pulumi.get(self, "peer_asn")
 
     @peer_asn.setter
-    def peer_asn(self, value: Optional[pulumi.Input[_builtins.int]]):
+    def peer_asn(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "peer_asn", value)
 
 
@@ -246,9 +264,9 @@ if not MYPY:
 
         The following arguments are optional:
         """
-        peer_asn: NotRequired[pulumi.Input[_builtins.int]]
+        peer_asn: NotRequired[pulumi.Input[_builtins.str]]
         """
-        Peer ASN.
+        Peer ASN. Supports 2-byte and 4-byte ASNs (1 to 4294967295).
         """
 elif False:
     ConnectPeerConfigurationBgpConfigurationArgsDict: TypeAlias = Mapping[str, Any]
@@ -259,13 +277,13 @@ class ConnectPeerConfigurationBgpConfigurationArgs:
                  core_network_address: Optional[pulumi.Input[_builtins.str]] = None,
                  core_network_asn: Optional[pulumi.Input[_builtins.int]] = None,
                  peer_address: Optional[pulumi.Input[_builtins.str]] = None,
-                 peer_asn: Optional[pulumi.Input[_builtins.int]] = None):
+                 peer_asn: Optional[pulumi.Input[_builtins.str]] = None):
         """
         :param pulumi.Input[_builtins.str] core_network_address: Connect peer core network address.
         :param pulumi.Input[_builtins.str] peer_address: Connect peer address.
                
                The following arguments are optional:
-        :param pulumi.Input[_builtins.int] peer_asn: Peer ASN.
+        :param pulumi.Input[_builtins.str] peer_asn: Peer ASN. Supports 2-byte and 4-byte ASNs (1 to 4294967295).
         """
         if core_network_address is not None:
             pulumi.set(__self__, "core_network_address", core_network_address)
@@ -313,14 +331,14 @@ class ConnectPeerConfigurationBgpConfigurationArgs:
 
     @_builtins.property
     @pulumi.getter(name="peerAsn")
-    def peer_asn(self) -> Optional[pulumi.Input[_builtins.int]]:
+    def peer_asn(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Peer ASN.
+        Peer ASN. Supports 2-byte and 4-byte ASNs (1 to 4294967295).
         """
         return pulumi.get(self, "peer_asn")
 
     @peer_asn.setter
-    def peer_asn(self, value: Optional[pulumi.Input[_builtins.int]]):
+    def peer_asn(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "peer_asn", value)
 
 
@@ -1105,7 +1123,7 @@ if not MYPY:
     class GetCoreNetworkPolicyDocumentAttachmentPolicyConditionArgsDict(TypedDict):
         type: _builtins.str
         """
-        Valid values include: `account-id`, `any`, `tag-value`, `tag-exists`, `resource-id`, `region`, `attachment-type`.
+        Must be `routing-policy-label`.
         """
         key: NotRequired[_builtins.str]
         """
@@ -1117,7 +1135,7 @@ if not MYPY:
         """
         value: NotRequired[_builtins.str]
         """
-        string value
+        Routing policy label to match.
         """
 elif False:
     GetCoreNetworkPolicyDocumentAttachmentPolicyConditionArgsDict: TypeAlias = Mapping[str, Any]
@@ -1130,10 +1148,10 @@ class GetCoreNetworkPolicyDocumentAttachmentPolicyConditionArgs:
                  operator: Optional[_builtins.str] = None,
                  value: Optional[_builtins.str] = None):
         """
-        :param _builtins.str type: Valid values include: `account-id`, `any`, `tag-value`, `tag-exists`, `resource-id`, `region`, `attachment-type`.
+        :param _builtins.str type: Must be `routing-policy-label`.
         :param _builtins.str key: string value
         :param _builtins.str operator: Valid values include: `equals`, `not-equals`, `contains`, `begins-with`.
-        :param _builtins.str value: string value
+        :param _builtins.str value: Routing policy label to match.
         """
         pulumi.set(__self__, "type", type)
         if key is not None:
@@ -1147,7 +1165,7 @@ class GetCoreNetworkPolicyDocumentAttachmentPolicyConditionArgs:
     @pulumi.getter
     def type(self) -> _builtins.str:
         """
-        Valid values include: `account-id`, `any`, `tag-value`, `tag-exists`, `resource-id`, `region`, `attachment-type`.
+        Must be `routing-policy-label`.
         """
         return pulumi.get(self, "type")
 
@@ -1183,7 +1201,7 @@ class GetCoreNetworkPolicyDocumentAttachmentPolicyConditionArgs:
     @pulumi.getter
     def value(self) -> Optional[_builtins.str]:
         """
-        string value
+        Routing policy label to match.
         """
         return pulumi.get(self, "value")
 
@@ -1192,6 +1210,196 @@ class GetCoreNetworkPolicyDocumentAttachmentPolicyConditionArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleArgsDict(TypedDict):
+        action: 'GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleActionArgsDict'
+        """
+        Block defining the action to take when conditions match. Detailed below.
+        """
+        conditions: Sequence['GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleConditionArgsDict']
+        """
+        A block argument. Detailed below.
+        """
+        rule_number: _builtins.int
+        """
+        An integer from `1` to `65535` indicating the rule's order number. Rules are processed in order from the lowest numbered rule to the highest. Rules stop processing when a rule is matched.
+        """
+        description: NotRequired[_builtins.str]
+        """
+        A user-defined description that further helps identify the rule.
+        """
+        edge_locations: NotRequired[Sequence[_builtins.str]]
+        """
+        A set of AWS Region codes where this rule applies.
+        """
+elif False:
+    GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleArgs:
+    def __init__(__self__, *,
+                 action: 'GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleActionArgs',
+                 conditions: Sequence['GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleConditionArgs'],
+                 rule_number: _builtins.int,
+                 description: Optional[_builtins.str] = None,
+                 edge_locations: Optional[Sequence[_builtins.str]] = None):
+        """
+        :param 'GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleActionArgs' action: Block defining the action to take when conditions match. Detailed below.
+        :param Sequence['GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleConditionArgs'] conditions: A block argument. Detailed below.
+        :param _builtins.int rule_number: An integer from `1` to `65535` indicating the rule's order number. Rules are processed in order from the lowest numbered rule to the highest. Rules stop processing when a rule is matched.
+        :param _builtins.str description: A user-defined description that further helps identify the rule.
+        :param Sequence[_builtins.str] edge_locations: A set of AWS Region codes where this rule applies.
+        """
+        pulumi.set(__self__, "action", action)
+        pulumi.set(__self__, "conditions", conditions)
+        pulumi.set(__self__, "rule_number", rule_number)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if edge_locations is not None:
+            pulumi.set(__self__, "edge_locations", edge_locations)
+
+    @_builtins.property
+    @pulumi.getter
+    def action(self) -> 'GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleActionArgs':
+        """
+        Block defining the action to take when conditions match. Detailed below.
+        """
+        return pulumi.get(self, "action")
+
+    @action.setter
+    def action(self, value: 'GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleActionArgs'):
+        pulumi.set(self, "action", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def conditions(self) -> Sequence['GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleConditionArgs']:
+        """
+        A block argument. Detailed below.
+        """
+        return pulumi.get(self, "conditions")
+
+    @conditions.setter
+    def conditions(self, value: Sequence['GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleConditionArgs']):
+        pulumi.set(self, "conditions", value)
+
+    @_builtins.property
+    @pulumi.getter(name="ruleNumber")
+    def rule_number(self) -> _builtins.int:
+        """
+        An integer from `1` to `65535` indicating the rule's order number. Rules are processed in order from the lowest numbered rule to the highest. Rules stop processing when a rule is matched.
+        """
+        return pulumi.get(self, "rule_number")
+
+    @rule_number.setter
+    def rule_number(self, value: _builtins.int):
+        pulumi.set(self, "rule_number", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def description(self) -> Optional[_builtins.str]:
+        """
+        A user-defined description that further helps identify the rule.
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[_builtins.str]):
+        pulumi.set(self, "description", value)
+
+    @_builtins.property
+    @pulumi.getter(name="edgeLocations")
+    def edge_locations(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        A set of AWS Region codes where this rule applies.
+        """
+        return pulumi.get(self, "edge_locations")
+
+    @edge_locations.setter
+    def edge_locations(self, value: Optional[Sequence[_builtins.str]]):
+        pulumi.set(self, "edge_locations", value)
+
+
+if not MYPY:
+    class GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleActionArgsDict(TypedDict):
+        associate_routing_policies: Sequence[_builtins.str]
+        """
+        Set of routing policy names to associate when the conditions match.
+        """
+elif False:
+    GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleActionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleActionArgs:
+    def __init__(__self__, *,
+                 associate_routing_policies: Sequence[_builtins.str]):
+        """
+        :param Sequence[_builtins.str] associate_routing_policies: Set of routing policy names to associate when the conditions match.
+        """
+        pulumi.set(__self__, "associate_routing_policies", associate_routing_policies)
+
+    @_builtins.property
+    @pulumi.getter(name="associateRoutingPolicies")
+    def associate_routing_policies(self) -> Sequence[_builtins.str]:
+        """
+        Set of routing policy names to associate when the conditions match.
+        """
+        return pulumi.get(self, "associate_routing_policies")
+
+    @associate_routing_policies.setter
+    def associate_routing_policies(self, value: Sequence[_builtins.str]):
+        pulumi.set(self, "associate_routing_policies", value)
+
+
+if not MYPY:
+    class GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleConditionArgsDict(TypedDict):
+        type: _builtins.str
+        """
+        Must be `routing-policy-label`.
+        """
+        value: _builtins.str
+        """
+        Routing policy label to match.
+        """
+elif False:
+    GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetCoreNetworkPolicyDocumentAttachmentRoutingPolicyRuleConditionArgs:
+    def __init__(__self__, *,
+                 type: _builtins.str,
+                 value: _builtins.str):
+        """
+        :param _builtins.str type: Must be `routing-policy-label`.
+        :param _builtins.str value: Routing policy label to match.
+        """
+        pulumi.set(__self__, "type", type)
+        pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> _builtins.str:
+        """
+        Must be `routing-policy-label`.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: _builtins.str):
+        pulumi.set(self, "type", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> _builtins.str:
+        """
+        Routing policy label to match.
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: _builtins.str):
+        pulumi.set(self, "value", value)
+
+
 if not MYPY:
     class GetCoreNetworkPolicyDocumentCoreNetworkConfigurationArgsDict(TypedDict):
         asn_ranges: Sequence[_builtins.str]
@@ -1456,6 +1664,336 @@ class GetCoreNetworkPolicyDocumentNetworkFunctionGroupArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class GetCoreNetworkPolicyDocumentRoutingPolicyArgsDict(TypedDict):
+        routing_policy_direction: _builtins.str
+        """
+        Direction of the routing policy. Valid values: `inbound`, `outbound`.
+        """
+        routing_policy_name: _builtins.str
+        """
+        Name of the routing policy. Must be 1-100 alphanumeric characters.
+        """
+        routing_policy_number: _builtins.int
+        """
+        Priority number for the routing policy. Must be between 1 and 9999. Lower numbers are evaluated first.
+        """
+        routing_policy_rules: Sequence['GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleArgsDict']
+        """
+        List of routing policy rules. Each rule defines match conditions and actions. Detailed below.
+        """
+        routing_policy_description: NotRequired[_builtins.str]
+        """
+        Description of the routing policy.
+        """
+elif False:
+    GetCoreNetworkPolicyDocumentRoutingPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetCoreNetworkPolicyDocumentRoutingPolicyArgs:
+    def __init__(__self__, *,
+                 routing_policy_direction: _builtins.str,
+                 routing_policy_name: _builtins.str,
+                 routing_policy_number: _builtins.int,
+                 routing_policy_rules: Sequence['GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleArgs'],
+                 routing_policy_description: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str routing_policy_direction: Direction of the routing policy. Valid values: `inbound`, `outbound`.
+        :param _builtins.str routing_policy_name: Name of the routing policy. Must be 1-100 alphanumeric characters.
+        :param _builtins.int routing_policy_number: Priority number for the routing policy. Must be between 1 and 9999. Lower numbers are evaluated first.
+        :param Sequence['GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleArgs'] routing_policy_rules: List of routing policy rules. Each rule defines match conditions and actions. Detailed below.
+        :param _builtins.str routing_policy_description: Description of the routing policy.
+        """
+        pulumi.set(__self__, "routing_policy_direction", routing_policy_direction)
+        pulumi.set(__self__, "routing_policy_name", routing_policy_name)
+        pulumi.set(__self__, "routing_policy_number", routing_policy_number)
+        pulumi.set(__self__, "routing_policy_rules", routing_policy_rules)
+        if routing_policy_description is not None:
+            pulumi.set(__self__, "routing_policy_description", routing_policy_description)
+
+    @_builtins.property
+    @pulumi.getter(name="routingPolicyDirection")
+    def routing_policy_direction(self) -> _builtins.str:
+        """
+        Direction of the routing policy. Valid values: `inbound`, `outbound`.
+        """
+        return pulumi.get(self, "routing_policy_direction")
+
+    @routing_policy_direction.setter
+    def routing_policy_direction(self, value: _builtins.str):
+        pulumi.set(self, "routing_policy_direction", value)
+
+    @_builtins.property
+    @pulumi.getter(name="routingPolicyName")
+    def routing_policy_name(self) -> _builtins.str:
+        """
+        Name of the routing policy. Must be 1-100 alphanumeric characters.
+        """
+        return pulumi.get(self, "routing_policy_name")
+
+    @routing_policy_name.setter
+    def routing_policy_name(self, value: _builtins.str):
+        pulumi.set(self, "routing_policy_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="routingPolicyNumber")
+    def routing_policy_number(self) -> _builtins.int:
+        """
+        Priority number for the routing policy. Must be between 1 and 9999. Lower numbers are evaluated first.
+        """
+        return pulumi.get(self, "routing_policy_number")
+
+    @routing_policy_number.setter
+    def routing_policy_number(self, value: _builtins.int):
+        pulumi.set(self, "routing_policy_number", value)
+
+    @_builtins.property
+    @pulumi.getter(name="routingPolicyRules")
+    def routing_policy_rules(self) -> Sequence['GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleArgs']:
+        """
+        List of routing policy rules. Each rule defines match conditions and actions. Detailed below.
+        """
+        return pulumi.get(self, "routing_policy_rules")
+
+    @routing_policy_rules.setter
+    def routing_policy_rules(self, value: Sequence['GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleArgs']):
+        pulumi.set(self, "routing_policy_rules", value)
+
+    @_builtins.property
+    @pulumi.getter(name="routingPolicyDescription")
+    def routing_policy_description(self) -> Optional[_builtins.str]:
+        """
+        Description of the routing policy.
+        """
+        return pulumi.get(self, "routing_policy_description")
+
+    @routing_policy_description.setter
+    def routing_policy_description(self, value: Optional[_builtins.str]):
+        pulumi.set(self, "routing_policy_description", value)
+
+
+if not MYPY:
+    class GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleArgsDict(TypedDict):
+        rule_definition: 'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionArgsDict'
+        """
+        Defines the match conditions and actions for the rule. Detailed below.
+        """
+        rule_number: _builtins.int
+        """
+        Priority number for the rule within the routing policy. Must be between 1 and 9999. Lower numbers are evaluated first.
+        """
+elif False:
+    GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleArgs:
+    def __init__(__self__, *,
+                 rule_definition: 'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionArgs',
+                 rule_number: _builtins.int):
+        """
+        :param 'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionArgs' rule_definition: Defines the match conditions and actions for the rule. Detailed below.
+        :param _builtins.int rule_number: Priority number for the rule within the routing policy. Must be between 1 and 9999. Lower numbers are evaluated first.
+        """
+        pulumi.set(__self__, "rule_definition", rule_definition)
+        pulumi.set(__self__, "rule_number", rule_number)
+
+    @_builtins.property
+    @pulumi.getter(name="ruleDefinition")
+    def rule_definition(self) -> 'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionArgs':
+        """
+        Defines the match conditions and actions for the rule. Detailed below.
+        """
+        return pulumi.get(self, "rule_definition")
+
+    @rule_definition.setter
+    def rule_definition(self, value: 'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionArgs'):
+        pulumi.set(self, "rule_definition", value)
+
+    @_builtins.property
+    @pulumi.getter(name="ruleNumber")
+    def rule_number(self) -> _builtins.int:
+        """
+        Priority number for the rule within the routing policy. Must be between 1 and 9999. Lower numbers are evaluated first.
+        """
+        return pulumi.get(self, "rule_number")
+
+    @rule_number.setter
+    def rule_number(self, value: _builtins.int):
+        pulumi.set(self, "rule_number", value)
+
+
+if not MYPY:
+    class GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionArgsDict(TypedDict):
+        action: 'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionActionArgsDict'
+        """
+        Block defining the action to take when conditions match. Detailed below.
+        """
+        condition_logic: NotRequired[_builtins.str]
+        """
+        Logic to apply when multiple match conditions are present. Valid values: `and`, `or`.
+        """
+        match_conditions: NotRequired[Sequence['GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionMatchConditionArgsDict']]
+        """
+        List of conditions to match against routes. Detailed below.
+        """
+elif False:
+    GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionArgs:
+    def __init__(__self__, *,
+                 action: 'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionActionArgs',
+                 condition_logic: Optional[_builtins.str] = None,
+                 match_conditions: Optional[Sequence['GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionMatchConditionArgs']] = None):
+        """
+        :param 'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionActionArgs' action: Block defining the action to take when conditions match. Detailed below.
+        :param _builtins.str condition_logic: Logic to apply when multiple match conditions are present. Valid values: `and`, `or`.
+        :param Sequence['GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionMatchConditionArgs'] match_conditions: List of conditions to match against routes. Detailed below.
+        """
+        pulumi.set(__self__, "action", action)
+        if condition_logic is not None:
+            pulumi.set(__self__, "condition_logic", condition_logic)
+        if match_conditions is not None:
+            pulumi.set(__self__, "match_conditions", match_conditions)
+
+    @_builtins.property
+    @pulumi.getter
+    def action(self) -> 'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionActionArgs':
+        """
+        Block defining the action to take when conditions match. Detailed below.
+        """
+        return pulumi.get(self, "action")
+
+    @action.setter
+    def action(self, value: 'GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionActionArgs'):
+        pulumi.set(self, "action", value)
+
+    @_builtins.property
+    @pulumi.getter(name="conditionLogic")
+    def condition_logic(self) -> Optional[_builtins.str]:
+        """
+        Logic to apply when multiple match conditions are present. Valid values: `and`, `or`.
+        """
+        return pulumi.get(self, "condition_logic")
+
+    @condition_logic.setter
+    def condition_logic(self, value: Optional[_builtins.str]):
+        pulumi.set(self, "condition_logic", value)
+
+    @_builtins.property
+    @pulumi.getter(name="matchConditions")
+    def match_conditions(self) -> Optional[Sequence['GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionMatchConditionArgs']]:
+        """
+        List of conditions to match against routes. Detailed below.
+        """
+        return pulumi.get(self, "match_conditions")
+
+    @match_conditions.setter
+    def match_conditions(self, value: Optional[Sequence['GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionMatchConditionArgs']]):
+        pulumi.set(self, "match_conditions", value)
+
+
+if not MYPY:
+    class GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionActionArgsDict(TypedDict):
+        type: _builtins.str
+        """
+        Type of action to perform. Valid values: `drop`, `allow`, `summarize`, `prepend-asn-list`, `remove-asn-list`, `replace-asn-list`, `add-community`, `remove-community`, `set-med`, `set-local-preference`.
+        """
+        value: NotRequired[_builtins.str]
+        """
+        Value for the action, required for certain action types.
+        """
+elif False:
+    GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionActionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionActionArgs:
+    def __init__(__self__, *,
+                 type: _builtins.str,
+                 value: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str type: Type of action to perform. Valid values: `drop`, `allow`, `summarize`, `prepend-asn-list`, `remove-asn-list`, `replace-asn-list`, `add-community`, `remove-community`, `set-med`, `set-local-preference`.
+        :param _builtins.str value: Value for the action, required for certain action types.
+        """
+        pulumi.set(__self__, "type", type)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> _builtins.str:
+        """
+        Type of action to perform. Valid values: `drop`, `allow`, `summarize`, `prepend-asn-list`, `remove-asn-list`, `replace-asn-list`, `add-community`, `remove-community`, `set-med`, `set-local-preference`.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: _builtins.str):
+        pulumi.set(self, "type", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[_builtins.str]:
+        """
+        Value for the action, required for certain action types.
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: Optional[_builtins.str]):
+        pulumi.set(self, "value", value)
+
+
+if not MYPY:
+    class GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionMatchConditionArgsDict(TypedDict):
+        type: _builtins.str
+        """
+        Type of condition to match. Valid values: `prefix-equals`, `prefix-in-cidr`, `prefix-in-prefix-list`, `asn-in-as-path`, `community-in-list`, `med-equals`.
+        """
+        value: _builtins.str
+        """
+        Value to match against, depending on the condition type.
+        """
+elif False:
+    GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionMatchConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetCoreNetworkPolicyDocumentRoutingPolicyRoutingPolicyRuleRuleDefinitionMatchConditionArgs:
+    def __init__(__self__, *,
+                 type: _builtins.str,
+                 value: _builtins.str):
+        """
+        :param _builtins.str type: Type of condition to match. Valid values: `prefix-equals`, `prefix-in-cidr`, `prefix-in-prefix-list`, `asn-in-as-path`, `community-in-list`, `med-equals`.
+        :param _builtins.str value: Value to match against, depending on the condition type.
+        """
+        pulumi.set(__self__, "type", type)
+        pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> _builtins.str:
+        """
+        Type of condition to match. Valid values: `prefix-equals`, `prefix-in-cidr`, `prefix-in-prefix-list`, `asn-in-as-path`, `community-in-list`, `med-equals`.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: _builtins.str):
+        pulumi.set(self, "type", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> _builtins.str:
+        """
+        Value to match against, depending on the condition type.
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: _builtins.str):
+        pulumi.set(self, "value", value)
+
+
 if not MYPY:
     class GetCoreNetworkPolicyDocumentSegmentArgsDict(TypedDict):
         name: _builtins.str
@@ -1611,7 +2149,7 @@ if not MYPY:
     class GetCoreNetworkPolicyDocumentSegmentActionArgsDict(TypedDict):
         action: _builtins.str
         """
-        Action to take for the chosen segment. Valid values: `create-route`, `share`, `send-via` and `send-to`.
+        Action to take for the chosen segment. Valid values: `create-route`, `share`, `send-via`, `send-to`, and `associate-routing-policy` (available in policy version `2025.11` and later).
         """
         segment: _builtins.str
         """
@@ -1629,6 +2167,10 @@ if not MYPY:
         """
         A list of strings. Valid values include `["blackhole"]` or a list of attachment ids.
         """
+        edge_location_association: NotRequired['GetCoreNetworkPolicyDocumentSegmentActionEdgeLocationAssociationArgsDict']
+        """
+        Associates routing policies with specific edge location pairs. Available in policy version `2025.11` and later. Detailed below.
+        """
         mode: NotRequired[_builtins.str]
         """
         String. When `action` is `share`, a `mode` value of `attachment-route` places the attachment and return routes in each of the `share_with` segments. When `action` is `send-via`, indicates the mode used for packets. Valid values: `attachment-route`, `single-hop`, `dual-hop`.
@@ -1660,17 +2202,19 @@ class GetCoreNetworkPolicyDocumentSegmentActionArgs:
                  description: Optional[_builtins.str] = None,
                  destination_cidr_blocks: Optional[Sequence[_builtins.str]] = None,
                  destinations: Optional[Sequence[_builtins.str]] = None,
+                 edge_location_association: Optional['GetCoreNetworkPolicyDocumentSegmentActionEdgeLocationAssociationArgs'] = None,
                  mode: Optional[_builtins.str] = None,
                  share_with_excepts: Optional[Sequence[_builtins.str]] = None,
                  share_withs: Optional[Sequence[_builtins.str]] = None,
                  via: Optional['GetCoreNetworkPolicyDocumentSegmentActionViaArgs'] = None,
                  when_sent_to: Optional['GetCoreNetworkPolicyDocumentSegmentActionWhenSentToArgs'] = None):
         """
-        :param _builtins.str action: Action to take for the chosen segment. Valid values: `create-route`, `share`, `send-via` and `send-to`.
+        :param _builtins.str action: Action to take for the chosen segment. Valid values: `create-route`, `share`, `send-via`, `send-to`, and `associate-routing-policy` (available in policy version `2025.11` and later).
         :param _builtins.str segment: Name of the segment.
         :param _builtins.str description: A user-defined string describing the segment action.
         :param Sequence[_builtins.str] destination_cidr_blocks: List of strings containing CIDRs. You can define the IPv4 and IPv6 CIDR notation for each AWS Region. For example, `10.1.0.0/16` or `2001:db8::/56`. This is an array of CIDR notation strings.
         :param Sequence[_builtins.str] destinations: A list of strings. Valid values include `["blackhole"]` or a list of attachment ids.
+        :param 'GetCoreNetworkPolicyDocumentSegmentActionEdgeLocationAssociationArgs' edge_location_association: Associates routing policies with specific edge location pairs. Available in policy version `2025.11` and later. Detailed below.
         :param _builtins.str mode: String. When `action` is `share`, a `mode` value of `attachment-route` places the attachment and return routes in each of the `share_with` segments. When `action` is `send-via`, indicates the mode used for packets. Valid values: `attachment-route`, `single-hop`, `dual-hop`.
         :param Sequence[_builtins.str] share_with_excepts: A set subtraction of segments to not share with.
         :param Sequence[_builtins.str] share_withs: A list of strings to share with. Must be a substring is all segments. Valid values include: `["*"]` or `["<segment-names>"]`.
@@ -1685,6 +2229,8 @@ class GetCoreNetworkPolicyDocumentSegmentActionArgs:
             pulumi.set(__self__, "destination_cidr_blocks", destination_cidr_blocks)
         if destinations is not None:
             pulumi.set(__self__, "destinations", destinations)
+        if edge_location_association is not None:
+            pulumi.set(__self__, "edge_location_association", edge_location_association)
         if mode is not None:
             pulumi.set(__self__, "mode", mode)
         if share_with_excepts is not None:
@@ -1700,7 +2246,7 @@ class GetCoreNetworkPolicyDocumentSegmentActionArgs:
     @pulumi.getter
     def action(self) -> _builtins.str:
         """
-        Action to take for the chosen segment. Valid values: `create-route`, `share`, `send-via` and `send-to`.
+        Action to take for the chosen segment. Valid values: `create-route`, `share`, `send-via`, `send-to`, and `associate-routing-policy` (available in policy version `2025.11` and later).
         """
         return pulumi.get(self, "action")
 
@@ -1756,6 +2302,18 @@ class GetCoreNetworkPolicyDocumentSegmentActionArgs:
     def destinations(self, value: Optional[Sequence[_builtins.str]]):
         pulumi.set(self, "destinations", value)
 
+    @_builtins.property
+    @pulumi.getter(name="edgeLocationAssociation")
+    def edge_location_association(self) -> Optional['GetCoreNetworkPolicyDocumentSegmentActionEdgeLocationAssociationArgs']:
+        """
+        Associates routing policies with specific edge location pairs. Available in policy version `2025.11` and later. Detailed below.
+        """
+        return pulumi.get(self, "edge_location_association")
+
+    @edge_location_association.setter
+    def edge_location_association(self, value: Optional['GetCoreNetworkPolicyDocumentSegmentActionEdgeLocationAssociationArgs']):
+        pulumi.set(self, "edge_location_association", value)
+
     @_builtins.property
     @pulumi.getter
     def mode(self) -> Optional[_builtins.str]:
@@ -1817,6 +2375,75 @@ class GetCoreNetworkPolicyDocumentSegmentActionArgs:
         pulumi.set(self, "when_sent_to", value)
 
 
+if not MYPY:
+    class GetCoreNetworkPolicyDocumentSegmentActionEdgeLocationAssociationArgsDict(TypedDict):
+        edge_location: _builtins.str
+        """
+        The AWS Region code for the first edge location in the association (e.g., `us-east-1`).
+        """
+        peer_edge_location: _builtins.str
+        """
+        The AWS Region code for the second edge location in the association (e.g., `us-west-2`).
+        """
+        routing_policy_names: Sequence[_builtins.str]
+        """
+        A set of routing policy names to apply to this edge location pair.
+        """
+elif False:
+    GetCoreNetworkPolicyDocumentSegmentActionEdgeLocationAssociationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetCoreNetworkPolicyDocumentSegmentActionEdgeLocationAssociationArgs:
+    def __init__(__self__, *,
+                 edge_location: _builtins.str,
+                 peer_edge_location: _builtins.str,
+                 routing_policy_names: Sequence[_builtins.str]):
+        """
+        :param _builtins.str edge_location: The AWS Region code for the first edge location in the association (e.g., `us-east-1`).
+        :param _builtins.str peer_edge_location: The AWS Region code for the second edge location in the association (e.g., `us-west-2`).
+        :param Sequence[_builtins.str] routing_policy_names: A set of routing policy names to apply to this edge location pair.
+        """
+        pulumi.set(__self__, "edge_location", edge_location)
+        pulumi.set(__self__, "peer_edge_location", peer_edge_location)
+        pulumi.set(__self__, "routing_policy_names", routing_policy_names)
+
+    @_builtins.property
+    @pulumi.getter(name="edgeLocation")
+    def edge_location(self) -> _builtins.str:
+        """
+        The AWS Region code for the first edge location in the association (e.g., `us-east-1`).
+        """
+        return pulumi.get(self, "edge_location")
+
+    @edge_location.setter
+    def edge_location(self, value: _builtins.str):
+        pulumi.set(self, "edge_location", value)
+
+    @_builtins.property
+    @pulumi.getter(name="peerEdgeLocation")
+    def peer_edge_location(self) -> _builtins.str:
+        """
+        The AWS Region code for the second edge location in the association (e.g., `us-west-2`).
+        """
+        return pulumi.get(self, "peer_edge_location")
+
+    @peer_edge_location.setter
+    def peer_edge_location(self, value: _builtins.str):
+        pulumi.set(self, "peer_edge_location", value)
+
+    @_builtins.property
+    @pulumi.getter(name="routingPolicyNames")
+    def routing_policy_names(self) -> Sequence[_builtins.str]:
+        """
+        A set of routing policy names to apply to this edge location pair.
+        """
+        return pulumi.get(self, "routing_policy_names")
+
+    @routing_policy_names.setter
+    def routing_policy_names(self, value: Sequence[_builtins.str]):
+        pulumi.set(self, "routing_policy_names", value)
+
+
 if not MYPY:
     class GetCoreNetworkPolicyDocumentSegmentActionViaArgsDict(TypedDict):
         network_function_groups: NotRequired[Sequence[_builtins.str]]