automapper_validation/generated/fv2604/

remadv_conditions_fv2604.rs

// <auto-generated>
// Generated by automapper-generator generate-conditions
// AHB: xml-migs-and-ahbs/FV2604/REMADV_AHB_1_0a_20251001.xml
// Generated: 2026-03-12T11:29:23Z
// </auto-generated>

#[allow(unused_imports)]
use crate::eval::format_validators::*;
use crate::eval::{ConditionEvaluator, ConditionResult, EvaluationContext};

/// Generated condition evaluator for REMADV FV2604.
pub struct RemadvConditionEvaluatorFV2604 {
    // External condition IDs that require runtime context.
    external_conditions: std::collections::HashSet<u32>,
}

impl Default for RemadvConditionEvaluatorFV2604 {
    fn default() -> Self {
        let mut external_conditions = std::collections::HashSet::new();
        external_conditions.insert(45);
        external_conditions.insert(492);
        external_conditions.insert(493);
        Self {
            external_conditions,
        }
    }
}

impl ConditionEvaluator for RemadvConditionEvaluatorFV2604 {
    fn message_type(&self) -> &str {
        "REMADV"
    }

    fn format_version(&self) -> &str {
        "FV2604"
    }

    fn evaluate(&self, condition: u32, ctx: &EvaluationContext) -> ConditionResult {
        match condition {
            2 => self.evaluate_2(ctx),
            3 => self.evaluate_3(ctx),
            4 => self.evaluate_4(ctx),
            8 => self.evaluate_8(ctx),
            9 => self.evaluate_9(ctx),
            11 => self.evaluate_11(ctx),
            12 => self.evaluate_12(ctx),
            14 => self.evaluate_14(ctx),
            15 => self.evaluate_15(ctx),
            16 => self.evaluate_16(ctx),
            18 => self.evaluate_18(ctx),
            22 => self.evaluate_22(ctx),
            26 => self.evaluate_26(ctx),
            28 => self.evaluate_28(ctx),
            33 => self.evaluate_33(ctx),
            34 => self.evaluate_34(ctx),
            35 => self.evaluate_35(ctx),
            36 => self.evaluate_36(ctx),
            39 => self.evaluate_39(ctx),
            40 => self.evaluate_40(ctx),
            41 => self.evaluate_41(ctx),
            42 => self.evaluate_42(ctx),
            43 => self.evaluate_43(ctx),
            45 => self.evaluate_45(ctx),
            47 => self.evaluate_47(ctx),
            48 => self.evaluate_48(ctx),
            49 => self.evaluate_49(ctx),
            50 => self.evaluate_50(ctx),
            51 => self.evaluate_51(ctx),
            52 => self.evaluate_52(ctx),
            53 => self.evaluate_53(ctx),
            54 => self.evaluate_54(ctx),
            55 => self.evaluate_55(ctx),
            56 => self.evaluate_56(ctx),
            57 => self.evaluate_57(ctx),
            58 => self.evaluate_58(ctx),
            59 => self.evaluate_59(ctx),
            60 => self.evaluate_60(ctx),
            61 => self.evaluate_61(ctx),
            62 => self.evaluate_62(ctx),
            63 => self.evaluate_63(ctx),
            64 => self.evaluate_64(ctx),
            65 => self.evaluate_65(ctx),
            66 => self.evaluate_66(ctx),
            67 => self.evaluate_67(ctx),
            68 => self.evaluate_68(ctx),
            69 => self.evaluate_69(ctx),
            70 => self.evaluate_70(ctx),
            71 => self.evaluate_71(ctx),
            72 => self.evaluate_72(ctx),
            73 => self.evaluate_73(ctx),
            74 => self.evaluate_74(ctx),
            75 => self.evaluate_75(ctx),
            76 => self.evaluate_76(ctx),
            77 => self.evaluate_77(ctx),
            78 => self.evaluate_78(ctx),
            79 => self.evaluate_79(ctx),
            80 => self.evaluate_80(ctx),
            81 => self.evaluate_81(ctx),
            82 => self.evaluate_82(ctx),
            83 => self.evaluate_83(ctx),
            84 => self.evaluate_84(ctx),
            85 => self.evaluate_85(ctx),
            86 => self.evaluate_86(ctx),
            87 => self.evaluate_87(ctx),
            88 => self.evaluate_88(ctx),
            89 => self.evaluate_89(ctx),
            90 => self.evaluate_90(ctx),
            91 => self.evaluate_91(ctx),
            92 => self.evaluate_92(ctx),
            93 => self.evaluate_93(ctx),
            94 => self.evaluate_94(ctx),
            95 => self.evaluate_95(ctx),
            96 => self.evaluate_96(ctx),
            97 => self.evaluate_97(ctx),
            98 => self.evaluate_98(ctx),
            99 => self.evaluate_99(ctx),
            100 => self.evaluate_100(ctx),
            101 => self.evaluate_101(ctx),
            102 => self.evaluate_102(ctx),
            103 => self.evaluate_103(ctx),
            104 => self.evaluate_104(ctx),
            105 => self.evaluate_105(ctx),
            106 => self.evaluate_106(ctx),
            107 => self.evaluate_107(ctx),
            108 => self.evaluate_108(ctx),
            109 => self.evaluate_109(ctx),
            110 => self.evaluate_110(ctx),
            111 => self.evaluate_111(ctx),
            112 => self.evaluate_112(ctx),
            113 => self.evaluate_113(ctx),
            114 => self.evaluate_114(ctx),
            115 => self.evaluate_115(ctx),
            116 => self.evaluate_116(ctx),
            117 => self.evaluate_117(ctx),
            118 => self.evaluate_118(ctx),
            119 => self.evaluate_119(ctx),
            120 => self.evaluate_120(ctx),
            121 => self.evaluate_121(ctx),
            492 => self.evaluate_492(ctx),
            493 => self.evaluate_493(ctx),
            501 => self.evaluate_501(ctx),
            502 => self.evaluate_502(ctx),
            503 => self.evaluate_503(ctx),
            510 => self.evaluate_510(ctx),
            511 => self.evaluate_511(ctx),
            512 => self.evaluate_512(ctx),
            515 => self.evaluate_515(ctx),
            517 => self.evaluate_517(ctx),
            518 => self.evaluate_518(ctx),
            519 => self.evaluate_519(ctx),
            520 => self.evaluate_520(ctx),
            521 => self.evaluate_521(ctx),
            523 => self.evaluate_523(ctx),
            525 => self.evaluate_525(ctx),
            526 => self.evaluate_526(ctx),
            529 => self.evaluate_529(ctx),
            533 => self.evaluate_533(ctx),
            534 => self.evaluate_534(ctx),
            535 => self.evaluate_535(ctx),
            536 => self.evaluate_536(ctx),
            537 => self.evaluate_537(ctx),
            538 => self.evaluate_538(ctx),
            544 => self.evaluate_544(ctx),
            548 => self.evaluate_548(ctx),
            549 => self.evaluate_549(ctx),
            926 => self.evaluate_926(ctx),
            930 => self.evaluate_930(ctx),
            931 => self.evaluate_931(ctx),
            939 => self.evaluate_939(ctx),
            940 => self.evaluate_940(ctx),
            _ => ConditionResult::Unknown,
        }
    }

    fn is_external(&self, condition: u32) -> bool {
        self.external_conditions.contains(&condition)
    }
    fn is_known(&self, condition: u32) -> bool {
        matches!(
            condition,
            2 | 3
                | 4
                | 8
                | 9
                | 11
                | 12
                | 14
                | 15
                | 16
                | 18
                | 22
                | 26
                | 28
                | 33
                | 34
                | 35
                | 36
                | 39
                | 40
                | 41
                | 42
                | 43
                | 45
                | 47
                | 48
                | 49
                | 50
                | 51
                | 52
                | 53
                | 54
                | 55
                | 56
                | 57
                | 58
                | 59
                | 60
                | 61
                | 62
                | 63
                | 64
                | 65
                | 66
                | 67
                | 68
                | 69
                | 70
                | 71
                | 72
                | 73
                | 74
                | 75
                | 76
                | 77
                | 78
                | 79
                | 80
                | 81
                | 82
                | 83
                | 84
                | 85
                | 86
                | 87
                | 88
                | 89
                | 90
                | 91
                | 92
                | 93
                | 94
                | 95
                | 96
                | 97
                | 98
                | 99
                | 100
                | 101
                | 102
                | 103
                | 104
                | 105
                | 106
                | 107
                | 108
                | 109
                | 110
                | 111
                | 112
                | 113
                | 114
                | 115
                | 116
                | 117
                | 118
                | 119
                | 120
                | 121
                | 492
                | 493
                | 501
                | 502
                | 503
                | 510
                | 511
                | 512
                | 515
                | 517
                | 518
                | 519
                | 520
                | 521
                | 523
                | 525
                | 526
                | 529
                | 533
                | 534
                | 535
                | 536
                | 537
                | 538
                | 544
                | 548
                | 549
                | 926
                | 930
                | 931
                | 939
                | 940
        )
    }
}

impl RemadvConditionEvaluatorFV2604 {
    /// [45] Nur MP-ID aus Sparte Strom
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_45(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("mp_id_is_strom_sector")
    }

    /// [121] Wenn SG7 AJT+A08/A99+E_3038 vorhanden
    // REVIEW: Checks for AJT segment in SG7 where DE4465 (elements[0][0]) is A08 or A99, AND DE1082 (elements[1][0]) is E_3038. Uses message-wide AJT search as fallback since the group navigator may not be available; SG7 AJT segments are distinct from SG12 AJT segments by their qualifier codes. Medium confidence because the exact E_3038 value was partially truncated in the notation resolution hint but matches the DE1082 code pattern seen in the schema (E_NNNN format). (medium confidence)
    fn evaluate_121(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Wenn SG7 AJT+A08/A99+E_3038 vorhanden
        // AJT elements[0][0] in {A08, A99} AND elements[1][0] == "E_3038"
        let ajts = ctx.find_segments("AJT");
        if ajts.is_empty() {
            return ConditionResult::False;
        }
        ConditionResult::from(ajts.iter().any(|s| {
            let code = s
                .elements
                .first()
                .and_then(|e| e.first())
                .map(|v| v.as_str());
            let pos = s
                .elements
                .get(1)
                .and_then(|e| e.first())
                .map(|v| v.as_str());
            matches!(code, Some("A08") | Some("A99")) && pos == Some("E_3038")
        }))
    }

    /// [2] Wenn SG7 AJT+28 vorhanden
    fn evaluate_2(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 0, "28", &["SG7"])
    }

    /// [3] Bei SG5 DOC+389 / Z25 ist der Wert aus derselben SG5 MOA+9 mit (-1) multipliziert anzugeben.
    fn evaluate_3(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Bei SG5 DOC+389/Z25 ist der Wert aus derselben SG5 MOA+9 mit (-1) multipliziert anzugeben.
        // Informational annotation describing the calculation rule for MOA+12 (Überweisungsbetrag).
        ConditionResult::True
    }

    /// [4] Bei SG5 DOC+380 / 457 ist der Wert aus derselben SG5 MOA+9 unverändert anzugeben.
    fn evaluate_4(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Bei SG5 DOC+380/457 ist der Wert aus derselben SG5 MOA+9 unverändert anzugeben.
        // Informational annotation describing that MOA+12 (Überweisungsbetrag) equals MOA+9 unchanged.
        ConditionResult::True
    }

    /// [8] Wenn SG7 AJT+A01/A02+E_0505 vorhanden
    fn evaluate_8(&self, ctx: &EvaluationContext) -> ConditionResult {
        let ajts = ctx.find_segments("AJT");
        let found = ajts.iter().any(|s| {
            let elem0 = s
                .elements
                .first()
                .and_then(|e| e.first())
                .map(|s| s.as_str())
                .unwrap_or("");
            let elem1 = s
                .elements
                .get(1)
                .and_then(|e| e.first())
                .map(|s| s.as_str())
                .unwrap_or("");
            (elem0 == "A01" || elem0 == "A02") && elem1 == "E_0505"
        });
        ConditionResult::from(found)
    }

    /// [9] Wenn SG7 AJT+A32/A99+E_0503 vorhanden
    fn evaluate_9(&self, ctx: &EvaluationContext) -> ConditionResult {
        let ajts = ctx.find_segments("AJT");
        let found = ajts.iter().any(|s| {
            let elem0 = s
                .elements
                .first()
                .and_then(|e| e.first())
                .map(|s| s.as_str())
                .unwrap_or("");
            let elem1 = s
                .elements
                .get(1)
                .and_then(|e| e.first())
                .map(|s| s.as_str())
                .unwrap_or("");
            (elem0 == "A32" || elem0 == "A99") && elem1 == "E_0503"
        });
        ConditionResult::from(found)
    }

    /// [11] Wenn in diesem AJT DE1082 = E_0406
    // REVIEW: Check if AJT has DE1082 (elements[1][0]) == E_0406. 'In diesem AJT' implies same-segment context; message-wide fallback via has_qualifier is the safe approximation without per-instance scoping. (medium confidence)
    fn evaluate_11(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualifier("AJT", 1, "E_0406")
    }

    /// [12] Wenn in diesem AJT DE1082 = E_0407
    // REVIEW: Check if AJT has DE1082 (elements[1][0]) == E_0407. Same pattern as condition 11. (medium confidence)
    fn evaluate_12(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualifier("AJT", 1, "E_0407")
    }

    /// [14] A-Code aus Cluster Ablehnung auf Kopfebene
    fn evaluate_14(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: A-Code aus Cluster Ablehnung auf Kopfebene — informational annotation
        // describing that this field's valid values come from the 'Ablehnung' code cluster at header level.
        ConditionResult::True
    }

    /// [15] A-Code aus Cluster Ablehnung auf Positionsebene
    fn evaluate_15(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: A-Code aus Cluster Ablehnung auf Positionsebene — informational annotation
        // describing that this field's valid values come from the 'Ablehnung' code cluster at position level.
        ConditionResult::True
    }

    /// [16] A-Code aus Cluster Ablehnung auf Summenebene
    fn evaluate_16(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: A-Code aus Cluster Ablehnung auf Summenebene — informational annotation
        // describing that this field's valid values come from the 'Ablehnung' code cluster at summary level.
        ConditionResult::True
    }

    /// [18] Wenn in dieser SG7 AJT DE4465 = A74/A75/A76/AC5
    fn evaluate_18(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_any_qualifier("AJT", 0, &["A74", "A75", "A76", "AC5"], &["SG7"])
    }

    /// [22] Wenn in dieser SG7 AJT DE4465 = A02/A06/A16/A66/A67/A68/A69/A78/A90/A95/A96/AC3/AC4
    fn evaluate_22(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_any_qualifier(
            "AJT",
            0,
            &[
                "A02", "A06", "A16", "A66", "A67", "A68", "A69", "A78", "A90", "A95", "A96", "AC3",
                "AC4",
            ],
            &["SG7"],
        )
    }

    /// [26] Wenn in dieser SG12 AJT DE4465 = A51/A62/A82/AA1/AA6/AA7/AB8/AD6
    fn evaluate_26(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_any_qualifier(
            "AJT",
            0,
            &["A51", "A62", "A82", "AA1", "AA6", "AA7", "AB8", "AD6"],
            &["SG12"],
        )
    }

    /// [28] Wenn in dieser SG12 AJT DE4465 = A23/A26/A35/A36/A38/A46/A47/A48/A50/A58/A59/A61/A77/A84/A99
    fn evaluate_28(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_any_qualifier(
            "AJT",
            0,
            &[
                "A23", "A26", "A35", "A36", "A38", "A46", "A47", "A48", "A50", "A58", "A59", "A61",
                "A77", "A84", "A99",
            ],
            &["SG12"],
        )
    }

    /// [33] Wenn in diesem AJT DE1082 = S_0103
    // REVIEW: Check if AJT has DE1082 (elements[1][0]) == S_0103. 'In diesem AJT' scoping approximated by message-wide check via has_qualifier. (medium confidence)
    fn evaluate_33(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualifier("AJT", 1, "S_0103")
    }

    /// [34] Wenn in diesem AJT DE1082 = S_0104
    fn evaluate_34(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualifier("AJT", 1, "S_0104")
    }

    /// [35] Wenn in dieser SG12 AJT DE4465 = A34/A39/AA2/AB2
    fn evaluate_35(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_any_qualifier("AJT", 0, &["A34", "A39", "AA2", "AB2"], &["SG12"])
    }

    /// [36] Wenn in dieser SG7 AJT DE4465 = A12/A75/A80/AE1
    fn evaluate_36(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_any_qualifier("AJT", 0, &["A12", "A75", "A80", "AE1"], &["SG7"])
    }

    /// [39] Wenn in dieser SG7 AJT DE4465 = AC1
    fn evaluate_39(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 0, "AC1", &["SG7"])
    }

    /// [40] Wenn in dieser SG7 AJT DE1082 = E_0406
    fn evaluate_40(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0406", &["SG7"])
    }

    /// [41] Wenn in dieser SG7 AJT DE1082 = E_0407
    fn evaluate_41(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0407", &["SG7"])
    }

    /// [42] Wenn in SG7 AJT DE1082 = E_0407/E_0568/E_0521/E_0517/E_0266
    fn evaluate_42(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_any_qualifier(
            "AJT",
            1,
            &["E_0407", "E_0568", "E_0521", "E_0517", "E_0266"],
            &["SG7"],
        )
    }

    /// [43] Wenn in SG12 AJT DE4465=28
    fn evaluate_43(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 0, "28", &["SG12"])
    }

    /// [47] Wenn in diesem AJT DE1082 = E_0210
    fn evaluate_47(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualifier("AJT", 1, "E_0210")
    }

    /// [48] Wenn in diesem AJT DE1082 = E_0259
    fn evaluate_48(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualifier("AJT", 1, "E_0259")
    }

    /// [49] Wenn in dieser SG7 AJT DE4465 = A01/A05/A22/A23/A90/A96
    fn evaluate_49(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_any_qualifier(
            "AJT",
            0,
            &["A01", "A05", "A22", "A23", "A90", "A96"],
            &["SG7"],
        )
    }

    /// [50] Wenn in dieser SG7 AJT DE4465 = A01/A05/A18/A19/A20/A90/A96
    fn evaluate_50(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_any_qualifier(
            "AJT",
            0,
            &["A01", "A05", "A18", "A19", "A20", "A90", "A96"],
            &["SG7"],
        )
    }

    /// [51] Wenn in dieser SG12 AJT DE1082 = E_0406
    fn evaluate_51(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0406", &["SG12"])
    }

    /// [52] Wenn in dieser SG12 AJT DE1082 = E_0407
    fn evaluate_52(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0407", &["SG12"])
    }

    /// [53] Wenn in dieser SG12 AJT DE4465 = A25/A31/A99/AF1
    fn evaluate_53(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_any_qualifier("AJT", 0, &["A25", "A31", "A99", "AF1"], &["SG5", "SG12"])
    }

    /// [54] Wenn in dieser SG12 AJT DE1082 = E_0210
    fn evaluate_54(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0210", &["SG5", "SG12"])
    }

    /// [55] Wenn in dieser SG12 AJT DE1082 = E_0259
    fn evaluate_55(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0259", &["SG5", "SG12"])
    }

    /// [56] Wenn in dieser SG7 AJT DE4465 = A21
    fn evaluate_56(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 0, "A21", &["SG5", "SG7"])
    }

    /// [57] Wenn in dieser SG7 AJT DE1082 = E_0210
    fn evaluate_57(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0210", &["SG5", "SG7"])
    }

    /// [58] Wenn in dieser SG7 AJT DE1082 = E_0259
    fn evaluate_58(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0259", &["SG5", "SG7"])
    }

    /// [59] Wenn SG7 AJT+A08/A99+E_0459 vorhanden
    fn evaluate_59(&self, ctx: &EvaluationContext) -> ConditionResult {
        {
            let ajt_segs = ctx.find_segments("AJT");
            let found = ajt_segs.iter().any(|s| {
                let qual = s
                    .elements
                    .first()
                    .and_then(|e| e.first())
                    .map(|v| v.as_str());
                let pos = s
                    .elements
                    .get(1)
                    .and_then(|e| e.first())
                    .map(|v| v.as_str());
                matches!(qual, Some("A08") | Some("A99")) && pos == Some("E_0459")
            });
            ConditionResult::from(found)
        }
    }

    /// [60] Wenn SG7 AJT+A99+E_0243 vorhanden
    fn evaluate_60(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 0, "A99", 1, 0, &["E_0243"], &["SG5", "SG7"])
    }

    /// [61] Wenn SG7 AJT+A99+E_0261 vorhanden
    fn evaluate_61(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 0, "A99", 1, 0, &["E_0261"], &["SG5", "SG7"])
    }

    /// [62] Wenn SG7 AJT+A99+E_1007 vorhanden
    fn evaluate_62(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 0, "A99", 1, 0, &["E_1007"], &["SG5", "SG7"])
    }

    /// [63] Wenn SG7 AJT+A01/A02+E_1009 vorhanden
    fn evaluate_63(&self, ctx: &EvaluationContext) -> ConditionResult {
        let a01 =
            ctx.any_group_has_qualified_value("AJT", 0, "A01", 1, 0, &["E_1009"], &["SG5", "SG7"]);
        let a02 =
            ctx.any_group_has_qualified_value("AJT", 0, "A02", 1, 0, &["E_1009"], &["SG5", "SG7"]);
        match (a01, a02) {
            (ConditionResult::True, _) | (_, ConditionResult::True) => ConditionResult::True,
            (ConditionResult::False, ConditionResult::False) => ConditionResult::False,
            _ => ConditionResult::Unknown,
        }
    }

    /// [64] Wenn in dieser SG12 AJT DE1082 = E_0264
    fn evaluate_64(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0264", &["SG5", "SG12"])
    }

    /// [65] Wenn in dieser SG12 AJT DE1082 = E_0515
    fn evaluate_65(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0515", &["SG5", "SG12"])
    }

    /// [66] Wenn in dieser SG12 AJT DE1082 = E_0519
    fn evaluate_66(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0519", &["SG5", "SG12"])
    }

    /// [67] Wenn in dieser SG12 AJT DE1082 = E_0266
    fn evaluate_67(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0266", &["SG5", "SG12"])
    }

    /// [68] Wenn in dieser SG12 AJT DE1082 = E_0517
    fn evaluate_68(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 1, "E_0517", 1, 0, &["E_0517"], &["SG12"])
    }

    /// [69] Wenn in dieser SG12 AJT DE1082 = E_0521
    fn evaluate_69(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 1, "E_0521", 1, 0, &["E_0521"], &["SG12"])
    }

    /// [70] Wenn in dieser SG12 AJT DE4465 = A15
    fn evaluate_70(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 0, "A15", &["SG12"])
    }

    /// [71] Wenn in dieser SG12 AJT DE4465 = A99
    fn evaluate_71(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 0, "A99", &["SG12"])
    }

    /// [72] Wenn SG7 AJT+A99+E_0518 vorhanden
    fn evaluate_72(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 0, "A99", 1, 0, &["E_0518"], &["SG7"])
    }

    /// [73] Wenn SG7 AJT+A99+E_0522 vorhanden
    fn evaluate_73(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 0, "A99", 1, 0, &["E_0522"], &["SG7"])
    }

    /// [74] Wenn SG7 AJT+A99+E_0267 vorhanden
    fn evaluate_74(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 0, "A99", 1, 0, &["E_0267"], &["SG7"])
    }

    /// [75] Wenn in diesem AJT DE1082 = E_0264
    // REVIEW: 'In diesem AJT' means current segment context; approximated as message-wide AJT search. DE1082 at elements[1][0]. Redundant qual+val check correctly matches E_0264. (medium confidence)
    fn evaluate_75(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualified_value("AJT", 1, "E_0264", 1, 0, &["E_0264"])
    }

    /// [76] Wenn in diesem AJT DE1082 = E_0266
    // REVIEW: Same pattern as 75, checking DE1082=E_0266 in any AJT segment. (medium confidence)
    fn evaluate_76(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualified_value("AJT", 1, "E_0266", 1, 0, &["E_0266"])
    }

    /// [77] Wenn in diesem AJT DE1082 = E_0515
    // REVIEW: Same pattern as 75, checking DE1082=E_0515 in any AJT segment. (medium confidence)
    fn evaluate_77(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualified_value("AJT", 1, "E_0515", 1, 0, &["E_0515"])
    }

    /// [78] Wenn in diesem AJT DE1082 = E_0517
    // REVIEW: Same pattern as 75, checking DE1082=E_0517 in any AJT segment. (medium confidence)
    fn evaluate_78(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualified_value("AJT", 1, "E_0517", 1, 0, &["E_0517"])
    }

    /// [79] Wenn in diesem AJT DE1082 = E_0519
    // REVIEW: Same pattern as 75, checking DE1082=E_0519 in any AJT segment. (medium confidence)
    fn evaluate_79(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualified_value("AJT", 1, "E_0519", 1, 0, &["E_0519"])
    }

    /// [80] Wenn in diesem AJT DE1082 = E_0521
    // REVIEW: Same pattern as 75, checking DE1082=E_0521 in any AJT segment. (medium confidence)
    fn evaluate_80(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualified_value("AJT", 1, "E_0521", 1, 0, &["E_0521"])
    }

    /// [81] Wenn in dieser SG7 AJT DE1082 = E_0264
    fn evaluate_81(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 1, "E_0264", 1, 0, &["E_0264"], &["SG7"])
    }

    /// [82] Wenn in dieser SG7 AJT DE1082 = E_0515
    fn evaluate_82(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 1, "E_0515", 1, 0, &["E_0515"], &["SG7"])
    }

    /// [83] Wenn in dieser SG7 AJT DE1082 = E_0519
    fn evaluate_83(&self, ctx: &EvaluationContext) -> ConditionResult {
        let values = ctx.collect_group_values("AJT", 1, 0, &["SG7"]);
        ConditionResult::from(values.iter().any(|(_, v)| v == "E_0519"))
    }

    /// [84] Wenn in dieser SG7 AJT DE1082 = E_0266
    fn evaluate_84(&self, ctx: &EvaluationContext) -> ConditionResult {
        let values = ctx.collect_group_values("AJT", 1, 0, &["SG7"]);
        ConditionResult::from(values.iter().any(|(_, v)| v == "E_0266"))
    }

    /// [85] Wenn in dieser SG7 AJT DE1082 = E_0517
    fn evaluate_85(&self, ctx: &EvaluationContext) -> ConditionResult {
        let values = ctx.collect_group_values("AJT", 1, 0, &["SG7"]);
        ConditionResult::from(values.iter().any(|(_, v)| v == "E_0517"))
    }

    /// [86] Wenn in dieser SG7 AJT DE1082 = E_0521
    fn evaluate_86(&self, ctx: &EvaluationContext) -> ConditionResult {
        let values = ctx.collect_group_values("AJT", 1, 0, &["SG7"]);
        ConditionResult::from(values.iter().any(|(_, v)| v == "E_0521"))
    }

    /// [87] Wenn in dieser SG7 AJT DE4465 = A05/A21/A22/A23/A90/A96/AE7
    fn evaluate_87(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_any_qualifier(
            "AJT",
            0,
            &["A05", "A21", "A22", "A23", "A90", "A96", "AE7"],
            &["SG7"],
        )
    }

    /// [88] Wenn in dieser SG7 AJT DE4465 = A25
    fn evaluate_88(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 0, "A25", &["SG7"])
    }

    /// [89] wenn im DE3155 in demselben COM der Code EM vorhanden ist
    fn evaluate_89(&self, ctx: &EvaluationContext) -> ConditionResult {
        let segs = ctx.find_segments("COM");
        ConditionResult::from(segs.iter().any(|s| {
            s.elements
                .first()
                .and_then(|e| e.get(1))
                .is_some_and(|v| v == "EM")
        }))
    }

    /// [90] wenn im DE3155 in demselben COM der Code TE / FX / AJ / AL vorhanden ist
    fn evaluate_90(&self, ctx: &EvaluationContext) -> ConditionResult {
        let segs = ctx.find_segments("COM");
        ConditionResult::from(segs.iter().any(|s| {
            s.elements
                .first()
                .and_then(|e| e.get(1))
                .is_some_and(|v| matches!(v.as_str(), "TE" | "FX" | "AJ" | "AL"))
        }))
    }

    /// [91] Wenn in diesem AJT DE1082 = E_0566
    fn evaluate_91(&self, ctx: &EvaluationContext) -> ConditionResult {
        let segs = ctx.find_segments("AJT");
        ConditionResult::from(segs.iter().any(|s| {
            s.elements
                .get(1)
                .and_then(|e| e.first())
                .is_some_and(|v| v == "E_0566")
        }))
    }

    /// [92] Wenn in diesem AJT DE1082 = E_0568
    fn evaluate_92(&self, ctx: &EvaluationContext) -> ConditionResult {
        let segs = ctx.find_segments("AJT");
        ConditionResult::from(segs.iter().any(|s| {
            s.elements
                .get(1)
                .and_then(|e| e.first())
                .is_some_and(|v| v == "E_0568")
        }))
    }

    /// [93] Wenn SG7 AJT+A99+E_0804 vorhanden
    fn evaluate_93(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 0, "A99", 1, 0, &["E_0804"], &["SG7"])
    }

    /// [94] Wenn SG7 AJT+A99+E_0806 vorhanden
    fn evaluate_94(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 0, "A99", 1, 0, &["E_0806"], &["SG7"])
    }

    /// [95] Wenn SG7 AJT+A99+E_0569 vorhanden
    fn evaluate_95(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 0, "A99", 1, 0, &["E_0569"], &["SG7"])
    }

    /// [96] Wenn SG7 AJT+E_0503/E_1007 vorhanden
    fn evaluate_96(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_any_qualifier("AJT", 0, &["E_0503", "E_1007"], &["SG7"])
    }

    /// [97] Wenn in dieser SG12 AJT DE4465 = A27
    fn evaluate_97(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 0, "A27", &["SG12"])
    }

    /// [98] Wenn in SG12 AJT DE1082 = E_0407
    fn evaluate_98(&self, ctx: &EvaluationContext) -> ConditionResult {
        let values = ctx.collect_group_values("AJT", 1, 0, &["SG12"]);
        ConditionResult::from(values.iter().any(|(_, v)| v == "E_0407"))
    }

    /// [99] Wenn in SG12 AJT DE1082 = E_0568
    // REVIEW: Checks any AJT segment in the message where DE1082 (elements[1][0]) equals E_0568. No 'dieser' qualifier so message-wide search is appropriate. SG12 scoping not enforced due to API limitations without group path context. (medium confidence)
    fn evaluate_99(&self, ctx: &EvaluationContext) -> ConditionResult {
        ConditionResult::from(ctx.find_segments("AJT").iter().any(|s| {
            s.elements
                .get(1)
                .and_then(|e| e.first())
                .is_some_and(|v| v == "E_0568")
        }))
    }

    /// [100] Wenn SG7 AJT+A01 vorhanden
    fn evaluate_100(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 0, "A01", &["SG5", "SG7"])
    }

    /// [101] Wenn in dieser SG7 AJT DE1082 = E_0566
    // REVIEW: Group-scoped check for AJT DE1082=E_0566 within SG7 (nested under SG5). Uses navigator to iterate SG7 instances; falls back to message-wide AJT scan when no navigator available. 'Dieser SG7' semantics best approximated by iterating all SG7 instances. (medium confidence)
    fn evaluate_101(&self, ctx: &EvaluationContext) -> ConditionResult {
        if let Some(nav) = ctx.navigator() {
            let count = nav.group_instance_count(&["SG5", "SG7"]);
            for i in 0..count {
                let ajts = nav.find_segments_in_group("AJT", &["SG5", "SG7"], i);
                if ajts.iter().any(|s| {
                    s.elements
                        .get(1)
                        .and_then(|e| e.first())
                        .is_some_and(|v| v == "E_0566")
                }) {
                    return ConditionResult::True;
                }
            }
            ConditionResult::False
        } else {
            ConditionResult::from(ctx.find_segments("AJT").iter().any(|s| {
                s.elements
                    .get(1)
                    .and_then(|e| e.first())
                    .is_some_and(|v| v == "E_0566")
            }))
        }
    }

    /// [102] Wenn in dieser SG7 AJT DE1082 = E_0568
    // REVIEW: Group-scoped check for AJT DE1082=E_0568 within SG7 (nested under SG5). Same pattern as condition 101 but checking E_0568 instead of E_0566. (medium confidence)
    fn evaluate_102(&self, ctx: &EvaluationContext) -> ConditionResult {
        if let Some(nav) = ctx.navigator() {
            let count = nav.group_instance_count(&["SG5", "SG7"]);
            for i in 0..count {
                let ajts = nav.find_segments_in_group("AJT", &["SG5", "SG7"], i);
                if ajts.iter().any(|s| {
                    s.elements
                        .get(1)
                        .and_then(|e| e.first())
                        .is_some_and(|v| v == "E_0568")
                }) {
                    return ConditionResult::True;
                }
            }
            ConditionResult::False
        } else {
            ConditionResult::from(ctx.find_segments("AJT").iter().any(|s| {
                s.elements
                    .get(1)
                    .and_then(|e| e.first())
                    .is_some_and(|v| v == "E_0568")
            }))
        }
    }

    /// [103] Wenn in dieser SG12 AJT DE1082 = E_0566
    // REVIEW: Group-scoped check for AJT DE1082=E_0566 within SG12 (nested under SG10 for line-item rejections). Uses navigator to iterate SG12 instances; falls back to message-wide scan. (medium confidence)
    fn evaluate_103(&self, ctx: &EvaluationContext) -> ConditionResult {
        if let Some(nav) = ctx.navigator() {
            let count = nav.group_instance_count(&["SG10", "SG12"]);
            for i in 0..count {
                let ajts = nav.find_segments_in_group("AJT", &["SG10", "SG12"], i);
                if ajts.iter().any(|s| {
                    s.elements
                        .get(1)
                        .and_then(|e| e.first())
                        .is_some_and(|v| v == "E_0566")
                }) {
                    return ConditionResult::True;
                }
            }
            ConditionResult::False
        } else {
            ConditionResult::from(ctx.find_segments("AJT").iter().any(|s| {
                s.elements
                    .get(1)
                    .and_then(|e| e.first())
                    .is_some_and(|v| v == "E_0566")
            }))
        }
    }

    /// [104] Wenn in dieser SG12 AJT DE1082 = E_0568
    // REVIEW: Group-scoped check for AJT DE1082=E_0568 within SG12 (nested under SG10). Same pattern as condition 103 but checking E_0568. (medium confidence)
    fn evaluate_104(&self, ctx: &EvaluationContext) -> ConditionResult {
        if let Some(nav) = ctx.navigator() {
            let count = nav.group_instance_count(&["SG10", "SG12"]);
            for i in 0..count {
                let ajts = nav.find_segments_in_group("AJT", &["SG10", "SG12"], i);
                if ajts.iter().any(|s| {
                    s.elements
                        .get(1)
                        .and_then(|e| e.first())
                        .is_some_and(|v| v == "E_0568")
                }) {
                    return ConditionResult::True;
                }
            }
            ConditionResult::False
        } else {
            ConditionResult::from(ctx.find_segments("AJT").iter().any(|s| {
                s.elements
                    .get(1)
                    .and_then(|e| e.first())
                    .is_some_and(|v| v == "E_0568")
            }))
        }
    }

    /// [105] Wenn in diesem AJT DE1082 = E_0270
    // REVIEW: Checks if any AJT segment has DE1082 (elements[1][0]) == 'E_0270'. 'In diesem AJT' refers to the current AJT context; without per-segment scope, we search all AJT segments. E_0270 appears in the SG12 AJT code list. Returns Unknown if no AJT segments exist. (medium confidence)
    fn evaluate_105(&self, ctx: &EvaluationContext) -> ConditionResult {
        let segs = ctx.find_segments("AJT");
        if segs.is_empty() {
            return ConditionResult::Unknown;
        }
        ConditionResult::from(segs.iter().any(|s| {
            s.elements
                .get(1)
                .and_then(|e| e.first())
                .is_some_and(|v| v == "E_0270")
        }))
    }

    /// [106] Wenn in diesem AJT DE1082 = E_0273
    // REVIEW: Checks if any AJT segment has DE1082 (elements[1][0]) == 'E_0273'. Same pattern as condition 105. (medium confidence)
    fn evaluate_106(&self, ctx: &EvaluationContext) -> ConditionResult {
        let segs = ctx.find_segments("AJT");
        if segs.is_empty() {
            return ConditionResult::Unknown;
        }
        ConditionResult::from(segs.iter().any(|s| {
            s.elements
                .get(1)
                .and_then(|e| e.first())
                .is_some_and(|v| v == "E_0273")
        }))
    }

    /// [107] Wenn in diesem AJT DE1082 = E_0276
    // REVIEW: Checks if any AJT segment has DE1082 (elements[1][0]) == 'E_0276'. Same pattern as condition 105. (medium confidence)
    fn evaluate_107(&self, ctx: &EvaluationContext) -> ConditionResult {
        let segs = ctx.find_segments("AJT");
        if segs.is_empty() {
            return ConditionResult::Unknown;
        }
        ConditionResult::from(segs.iter().any(|s| {
            s.elements
                .get(1)
                .and_then(|e| e.first())
                .is_some_and(|v| v == "E_0276")
        }))
    }

    /// [108] Wenn in diesem AJT DE1082 = E_0277
    // REVIEW: Checks if any AJT segment has DE1082 (elements[1][0]) == 'E_0277'. Same pattern as condition 105. (medium confidence)
    fn evaluate_108(&self, ctx: &EvaluationContext) -> ConditionResult {
        let segs = ctx.find_segments("AJT");
        if segs.is_empty() {
            return ConditionResult::Unknown;
        }
        ConditionResult::from(segs.iter().any(|s| {
            s.elements
                .get(1)
                .and_then(|e| e.first())
                .is_some_and(|v| v == "E_0277")
        }))
    }

    /// [109] Wenn in dieser SG7 AJT DE4465 = A01/A21/A22/A23/A90/A96
    fn evaluate_109(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_any_qualifier(
            "AJT",
            0,
            &["A01", "A21", "A22", "A23", "A90", "A96"],
            &["SG7"],
        )
    }

    /// [110] Wenn in dieser SG7 AJT DE1082 = E_0270
    fn evaluate_110(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0270", &["SG7"])
    }

    /// [111] Wenn in dieser SG7 AJT DE1082 = E_0273
    fn evaluate_111(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0273", &["SG7"])
    }

    /// [112] Wenn in dieser SG7 AJT DE1082 = E_0276
    fn evaluate_112(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0276", &["SG7"])
    }

    /// [113] Wenn in dieser SG7 AJT DE1082 = E_0277
    fn evaluate_113(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 1, "E_0277", &["SG7"])
    }

    /// [114] Wenn in dieser SG12 AJT DE1082 = E_0270
    fn evaluate_114(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 1, "E_0270", 1, 0, &["E_0270"], &["SG5", "SG12"])
    }

    /// [115] Wenn in dieser SG12 AJT DE1082 = E_0273
    fn evaluate_115(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 1, "E_0273", 1, 0, &["E_0273"], &["SG5", "SG12"])
    }

    /// [116] Wenn in dieser SG12 AJT DE1082 = E_0276
    fn evaluate_116(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 1, "E_0276", 1, 0, &["E_0276"], &["SG5", "SG12"])
    }

    /// [117] Wenn in dieser SG12 AJT DE1082 = E_0277
    fn evaluate_117(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualified_value("AJT", 1, "E_0277", 1, 0, &["E_0277"], &["SG5", "SG12"])
    }

    /// [118] Wenn SG7 AJT+A99+E_0272 vorhanden
    fn evaluate_118(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_segment_matching_in_group("AJT", &[(0, 0, "A99"), (1, 0, "E_0272")], &["SG7"])
    }

    /// [119] Wenn SG7 AJT+A99+E_0275 vorhanden
    fn evaluate_119(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_segment_matching_in_group("AJT", &[(0, 0, "A99"), (1, 0, "E_0275")], &["SG7"])
    }

    /// [120] Wenn in dieser SG7 AJT DE4465 = A01
    fn evaluate_120(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("AJT", 0, "A01", &["SG7"])
    }

    /// [492] Wenn MP-ID in NAD+MR (Nachrichtenempfänger) aus Sparte Strom
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_492(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("recipient_is_strom")
    }

    /// [493] Wenn MP-ID in NAD+MR (Nachrichtenempfänger) aus Sparte Gas
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_493(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("recipient_is_gas")
    }

    /// [501] Hinweis: An dieser Stelle ist der Betrag aus SG50 MOA+9 der zugrundeliegenden INVOIC zu übernehmen.
    fn evaluate_501(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: An dieser Stelle ist der Betrag aus SG50 MOA+9 der zugrundeliegenden INVOIC zu übernehmen.
        // Informational note — always applies
        ConditionResult::True
    }

    /// [502] Hinweis: Bei positivem Betrag ergibt sich eine Forderung des Rechnungsstellers. Bei negativem Betrag ergibt sich eine Forderung für den Rechnungsempfänger.
    fn evaluate_502(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Bei positivem Betrag ergibt sich eine Forderung des Rechnungsstellers.
        // Bei negativem Betrag ergibt sich eine Forderung für den Rechnungsempfänger.
        // Informational note — always applies
        ConditionResult::True
    }

    /// [503] Hinweis: Empfohlen, um bei Abweisung Ansprechpartner für Rückfragen zu erreichen.
    fn evaluate_503(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Empfohlen, um bei Abweisung Ansprechpartner für Rückfragen zu erreichen.
        // Informational note — always applies
        ConditionResult::True
    }

    /// [510] Hinweis: Bei Ablehnung einer vorherigen COMDIS
    fn evaluate_510(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Bei Ablehnung einer vorherigen COMDIS
        // Informational note — always applies
        ConditionResult::True
    }

    /// [511] Hinweis: BGM DE1004 aus der abgelehnten INVOIC-Nachricht
    fn evaluate_511(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: BGM DE1004 aus der abgelehnten INVOIC-Nachricht — informational note, always applies
        ConditionResult::True
    }

    /// [512] Hinweis: BGM DE1004 aus der abgelehnten COMDIS-Nachricht
    fn evaluate_512(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: BGM DE1004 aus der abgelehnten COMDIS-Nachricht — informational note, always applies
        ConditionResult::True
    }

    /// [515] Hinweis: BGM DE1004 aus der bestätigten INVOIC- Nachricht
    fn evaluate_515(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: BGM DE1004 aus der bestätigten INVOIC-Nachricht — informational note, always applies
        ConditionResult::True
    }

    /// [517] Hinweis: Wenn in dieser SG5 in AJT DE4465 ein Code aus Cluster Ablehnung auf Summenebene verwendet wird, ist diese SG7 so oft zu wiederholen, bis alle Fehler der Summenebene genannt sind.
    fn evaluate_517(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Cardinality guidance for SG7 repetition when AJT DE4465 uses a rejection code at sum level — informational note, always applies
        ConditionResult::True
    }

    /// [518] Hinweis: Wenn in dieser SG5 in AJT DE4465 ein Code aus Cluster Ablehnung auf Kopfebene verwendet wird, der von A80 abweicht, ist diese SG7 genau einmal zu nutzen.
    fn evaluate_518(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Cardinality guidance for SG7 — exactly once when AJT DE4465 uses a header-level rejection code other than A80 — informational note, always applies
        ConditionResult::True
    }

    /// [519] Hinweis: Diese SG7 ist so oft mit AJT DE4465 = A74 zu wiederholen, bis alle Rechnungsnummern im RFF-Segment dieser SG7 genannt sind, die in der INVOIC fehlen, die in diesem SG5 DOC DE1004 genannt ist
    fn evaluate_519(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Diese SG7 ist so oft mit AJT DE4465 = A74 zu wiederholen, bis alle Rechnungsnummern im RFF-Segment dieser SG7 genannt sind, die in der INVOIC fehlen, die in diesem SG5 DOC DE1004 genannt ist
        // Informational note, always applies
        ConditionResult::True
    }

    /// [520] Hinweis: Diese SG7 ist so oft mit AJT DE4465 = A75 zu wiederholen, bis alle Rechnungsnummern der Rechnungen genannt sind, die mindestens eine Abschlagsrechnung enthalten, die in der INVOIC abgerech...
    fn evaluate_520(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Diese SG7 ist so oft mit AJT DE4465 = A75 zu wiederholen, bis alle Rechnungsnummern der Rechnungen genannt sind, die mindestens eine Abschlagsrechnung enthalten, die in der INVOIC abgerechnet wurden, die in diesem SG5 DOC DE1004 genannt ist.
        // Informational note, always applies
        ConditionResult::True
    }

    /// [521] Hinweis: Diese SG7 ist so oft mit AJT DE4465 = A76 zu wiederholen, bis alle Rechnungsnummern der Abschlagsrechnungen genannt sind, die in der INVOIC, die in diesem SG5 DOC DE1004 genannt ist, nicht...
    fn evaluate_521(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Diese SG7 ist so oft mit AJT DE4465 = A76 zu wiederholen, bis alle Rechnungsnummern der Abschlagsrechnungen genannt sind, die in der INVOIC, die in diesem SG5 DOC DE1004 genannt ist, nicht hätten berücksichtigt werden dürfen.
        // Informational note, always applies
        ConditionResult::True
    }

    /// [523] Hinweis: Jede Rechnungsnummer einer Abschlagsrechnung muss in einem separaten DE4440 angegeben werden. Reichen die fünf DE4440 für die Rechnungsnummern aller anzugebenden Abschlagrechnungen nicht...
    fn evaluate_523(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Jede Rechnungsnummer einer Abschlagsrechnung muss in einem separaten DE4440 angegeben werden. Reichen die fünf DE4440 für die Rechnungsnummern aller anzugebenden Abschlagrechnungen nicht aus, ist das FTX+Z14 zu wiederholen.
        // Informational note, always applies
        ConditionResult::True
    }

    /// [525] Hinweis: Diese SG10 ist so oft zu wiederholen, bis alle Fehler der Positionsebene genannt sind.
    fn evaluate_525(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Diese SG10 ist so oft zu wiederholen, bis alle Fehler der Positionsebene genannt sind.
        // Informational note, always applies
        ConditionResult::True
    }

    /// [526] Hinweis: Wert aus DE1082 der SG26 in der sich der nachfolgende Fehler in der INVOIC befindet, die in diesem SG5 DOC DE1004 genannt ist.
    fn evaluate_526(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Wert aus DE1082 der SG26 in der sich der nachfolgende Fehler in der INVOIC befindet, die in diesem SG5 DOC DE1004 genannt ist.
        ConditionResult::True
    }

    /// [529] Hinweis: Wenn in dieser SG7 AJT DE4465 = A75 vorhanden, dann dürfen in den DE4440 dieses FTX-Segments nur Abschlagsrechnungsnummern genannt sein, welche in der Rechnung enthalten sind, deren Numme...
    // REVIEW: The trigger 'Wenn in dieser SG7 AJT DE4465=A75 vorhanden' is evaluable via group-scoped qualifier check on SG5.SG7. The subsequent content constraint (FTX DE4440 must contain only installment invoice numbers that appear in the invoice referenced by RFF+AFL) requires cross-message business context not available in the EDIFACT message itself, so only the trigger condition is implemented. (medium confidence)
    fn evaluate_529(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Check if this SG7 contains AJT DE4465=A75.
        // The content constraint on FTX DE4440 (only installment invoice numbers
        // from the referenced invoice) requires cross-message business context
        // and cannot be verified from EDIFACT structure alone.
        ctx.any_group_has_qualifier("AJT", 0, "A75", &["SG5", "SG7"])
    }

    /// [533] Hinweis: Wenn in dieser SG12 AJT DE4465 = AA1/AA6/AA7/AB8/AD6, ist diese SG12 so oft mit AJT DE4465 = Code zu wiederholen, bis alle Rechnungsnummern im RFF-Segment dieser SG12 genannt sind.
    // REVIEW: The trigger condition 'Wenn in dieser SG12 AJT DE4465=AA1/AA6/AA7/AB8/AD6' is evaluable via group-scoped multi-qualifier check on SG12. AJT DE4465 is at elements[0][0]. The subsequent repetition rule (how many times to repeat SG12) is informational and not a boolean condition. (medium confidence)
    fn evaluate_533(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Check if this SG12 contains AJT DE4465 with one of the specified codes.
        // When any of these codes is present, SG12 must be repeated until all
        // relevant invoice numbers are listed in RFF segments.
        ctx.any_group_has_any_qualifier("AJT", 0, &["AA1", "AA6", "AA7", "AB8", "AD6"], &["SG12"])
    }

    /// [534] Hinweis: Wenn in dieser SG12 AJT DE4465 = A34/A39/AA2/AB2, ist diese SG12 ist so oft mit AJT DE4465 = Code zu wiederholen, bis alle Nummern der Reklamationen im RFF-Segment dieser SG12 genannt sind.
    // REVIEW: The trigger condition 'Wenn in dieser SG12 AJT DE4465=A34/A39/AA2/AB2' is evaluable via group-scoped multi-qualifier check on SG12. AJT DE4465 is at elements[0][0]. The subsequent repetition rule is informational. (medium confidence)
    fn evaluate_534(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Check if this SG12 contains AJT DE4465 with one of the specified codes.
        // When any of these codes is present, SG12 must be repeated until all
        // relevant complaint/claim numbers are listed in RFF segments.
        ctx.any_group_has_any_qualifier("AJT", 0, &["A34", "A39", "AA2", "AB2"], &["SG12"])
    }

    /// [535] Hinweis: Diese SG7 ist so oft mit AJT DE4465 = A80 zu wiederholen, bis die Rechnungsnummern der nicht stornierten Sonderrechnungen mit derselben Sonderrechnungsart wie sie in Sonderrechnung genannt...
    fn evaluate_535(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Diese SG7 ist so oft mit AJT DE4465 = A80 zu wiederholen, bis die Rechnungsnummern der nicht stornierten Sonderrechnungen... — informational note about repetition cardinality, always applies
        ConditionResult::True
    }

    /// [536] Hinweis: Dieses DE darf keine Abschlagsrechnungsnummer enthalten
    fn evaluate_536(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Dieses DE darf keine Abschlagsrechnungsnummer enthalten — informational note about field usage restriction, always applies
        ConditionResult::True
    }

    /// [537] Hinweis: Diese SG7 ist so oft mit AJT DE4465 = AC5 zu wiederholen, bis alle Rechnungsnummern im RFF Segment dieser SG7 genannt sind, die in der INVOIC berücksichtigt werden sollten, die in diesem ...
    fn evaluate_537(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Diese SG7 ist so oft mit AJT DE4465 = AC5 zu wiederholen, bis alle Rechnungsnummern im RFF Segment dieser SG7 genannt sind... — informational note about repetition cardinality, always applies
        ConditionResult::True
    }

    /// [538] Hinweis: Jede Positionsnummer eines Angebotes muss in einem separaten DE4440 angegeben werden. Reichen die fünf DE4440 für die Positionsnummern aller anzugebenden Angebote nicht aus, ist das SG7 ...
    fn evaluate_538(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Jede Positionsnummer eines Angebotes muss in einem separaten DE4440 angegeben werden. Reichen die fünf DE4440 nicht aus, ist das SG7 FTX+Z16 zu wiederholen. — informational note about field usage, always applies
        ConditionResult::True
    }

    /// [544] Hinweis: Wenn in dieser SG7 AJT DE4465 = A21 vorhanden, dann darf in den DE4440 dieses FTX-Segments jeweils nur eine Positionsnummer genannt sein, welche aus dem bestätigten Angebot nicht in der R...
    fn evaluate_544(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Wenn AJT DE4465 = A21 vorhanden, dann darf in den DE4440 dieses FTX-Segments jeweils nur eine Positionsnummer genannt sein, welche aus dem bestätigten Angebot nicht in der Rechnung enthalten sind — informational note, always applies
        ConditionResult::True
    }

    /// [548] Hinweis: Die Befüllung des Datenelements ergibt sich aus dem zugehörigen EBD.
    fn evaluate_548(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Die Befüllung des Datenelements ergibt sich aus dem zugehörigen EBD.
        ConditionResult::True
    }

    /// [549] Hinweis: Es darf nur eine Information im DE3148 übermittelt werden
    fn evaluate_549(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Es darf nur eine Information im DE3148 übermittelt werden — informational note, always applies
        ConditionResult::True
    }

    /// [926] Format: Möglicher Wert: 0
    // REVIEW: Format condition checking that the value equals 0. Applied to MOA segment (monetary amount) which is the primary numeric field in REMADV. The segment is the most likely target for this constraint in REMADV context. (medium confidence)
    fn evaluate_926(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Format: Möglicher Wert: 0
        let segs = ctx.find_segments("MOA");
        match segs
            .first()
            .and_then(|s| s.elements.first())
            .and_then(|e| e.get(1))
        {
            Some(val) => validate_numeric(val, "==", 0.0),
            None => ConditionResult::False, // segment absent → condition not applicable
        }
    }

    /// [930] Format: max. 2 Nachkommastellen
    // REVIEW: Format condition for maximum 2 decimal places. Applied to MOA segment value (element[0][1]) which is the primary numeric data element in REMADV messages. (medium confidence)
    fn evaluate_930(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Format: max. 2 Nachkommastellen
        let segs = ctx.find_segments("MOA");
        match segs
            .first()
            .and_then(|s| s.elements.first())
            .and_then(|e| e.get(1))
        {
            Some(val) => validate_max_decimal_places(val, 2),
            None => ConditionResult::False, // segment absent → condition not applicable
        }
    }

    /// [931] Format: ZZZ = +00
    fn evaluate_931(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Format: ZZZ = +00 — timezone must be UTC
        let dtm_segs = ctx.find_segments("DTM");
        match dtm_segs
            .first()
            .and_then(|s| s.elements.first())
            .and_then(|e| e.get(1))
        {
            Some(val) => validate_timezone_utc(val),
            None => ConditionResult::False, // segment absent → condition not applicable
        }
    }

    /// [939] Format: Die Zeichenkette muss die Zeichen @ und . enthalten
    fn evaluate_939(&self, ctx: &EvaluationContext) -> ConditionResult {
        let segs = ctx.find_segments("COM");
        match segs
            .first()
            .and_then(|s| s.elements.first())
            .and_then(|e| e.first())
        {
            Some(val) => validate_email(val),
            None => ConditionResult::False, // segment absent → condition not applicable
        }
    }

    /// [940] Format: Die Zeichenkette muss mit dem Zeichen + beginnen und danach dürfen nur noch Ziffern folgen
    fn evaluate_940(&self, ctx: &EvaluationContext) -> ConditionResult {
        let segs = ctx.find_segments("COM");
        match segs
            .first()
            .and_then(|s| s.elements.first())
            .and_then(|e| e.first())
        {
            Some(val) => validate_phone(val),
            None => ConditionResult::False, // segment absent → condition not applicable
        }
    }
}