Index: src/org/openstreetmap/josm/data/validation/tests/TurnrestrictionTest.java
===================================================================
--- src/org/openstreetmap/josm/data/validation/tests/TurnrestrictionTest.java	(revision 18969)
+++ src/org/openstreetmap/josm/data/validation/tests/TurnrestrictionTest.java	(working copy)
@@ -51,6 +51,18 @@
             "no_entry", "no_exit"
         );
 
+    // This should really be replaced with a transport mode hierarchy, i.e. #18383
+    private static final List<String> SUPPORTED_VEHICLE_TYPES = Arrays.asList(
+            "agricultural", "bicycle", "bus", "caravan", "foot", "hazmat",
+            "hgv", "horse", "motor_vehicle", "motorcar", "motorcycle",
+            "psv", "vehicle"
+    );
+
+    /** A string for "restriction" */
+    private static final String RESTRICTION_STRING = "restriction";
+    /** A string for "conditional" */
+    private static final String CONDITIONAL_STRING = "conditional";
+
     /**
      * Constructs a new {@code TurnrestrictionTest}.
      */
@@ -58,24 +70,48 @@
         super(tr("Turn restrictions"), tr("This test checks if turn restrictions are valid."));
     }
 
-    private static boolean hasSupportedRestrictionTag(Relation r) {
-        if (r.hasTag("restriction", SUPPORTED_RESTRICTIONS))
-            return true;
-        String conditionalValue = r.get("restriction:conditional");
-        if (conditionalValue != null) {
+    /**
+     * Check for any restriction tag (e.g., "restriction:mode:conditional" or "restriction:conditional)
+     * @param key The key to check
+     * @param value The value to check
+     * @return {@code true} if the tag is supported
+     */
+    private static boolean restrictionTagIsSupported(final String key, final String value) {
+        if (!key.startsWith("restriction:"))
+            return false;
+        String[] parts = key.split(":");
+        if (parts.length > 3)
+            return false;
+        if (parts.length == 3 && !SUPPORTED_VEHICLE_TYPES.contains(parts[1]))
+            return false;
+        if (key.endsWith(CONDITIONAL_STRING)) {
+            // restriction:conditional=* or restriction:mode:condition=*
             try {
-                List<ConditionalValue> values = ConditionalValue.parse(conditionalValue);
-                return !values.isEmpty() && SUPPORTED_RESTRICTIONS.contains(values.get(0).restrictionValue);
+                final List<ConditionalValue> conditionalValues = ConditionalValue.parse(value);
+                return !conditionalValues.isEmpty() && conditionalValues.stream()
+                        .anyMatch(conditional -> SUPPORTED_RESTRICTIONS.contains(conditional.restrictionValue));
             } catch (ConditionalParsingException e) {
                 Logging.trace(e);
             }
+        } else if (SUPPORTED_VEHICLE_TYPES.contains(parts[1])) {
+            // restriction:mode=*
+            return SUPPORTED_RESTRICTIONS.contains(value);
         }
         return false;
     }
 
+    private static boolean hasSupportedRestrictionTag(Relation r) {
+        if (r.hasTag(RESTRICTION_STRING, SUPPORTED_RESTRICTIONS))
+            return true;
+        if (r.hasTag("restriction:bicycle", "give_way", "stop"))
+            return true;
+        return r.getKeys().entrySet().stream()
+                .anyMatch(entry -> restrictionTagIsSupported(entry.getKey(), entry.getValue()));
+    }
+
     @Override
     public void visit(Relation r) {
-        if (!r.hasTag("type", "restriction"))
+        if (!r.hasTag("type", RESTRICTION_STRING))
             return;
 
         if (!hasSupportedRestrictionTag(r)) {
@@ -224,7 +260,7 @@
             return;
         }
         if (fromWay.equals(toWay)) {
-            Severity severity = r.hasTag("restriction", "no_u_turn") ? Severity.OTHER : Severity.WARNING;
+            Severity severity = r.hasTag(RESTRICTION_STRING, "no_u_turn") ? Severity.OTHER : Severity.WARNING;
             errors.add(TestError.builder(this, severity, FROM_EQUALS_TO)
                     .message(tr("\"from\" way equals \"to\" way"))
                     .primitives(r)