automapper_validation/generated/fv2510/

pricat_conditions_fv2510.rs

// <auto-generated>
// Generated by automapper-generator generate-conditions
// AHB: xml-migs-and-ahbs/FV2510/PRICAT_AHB_2_0f_Fehlerkorrektur_20251211.xml
// Generated: 2026-03-12T10:50:19Z
// </auto-generated>

// LLM-produced bodies aren't idiomatic Rust — silence stylistic lints at
// file scope so `cargo clippy -D warnings` stays green. Correctness,
// suspicious, and perf categories stay on so real bugs still surface.
#![allow(clippy::style, clippy::complexity)]

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

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

impl Default for PricatConditionEvaluatorFV2510 {
    fn default() -> Self {
        let mut external_conditions = std::collections::HashSet::new();
        external_conditions.insert(1);
        external_conditions.insert(8);
        external_conditions.insert(14);
        external_conditions.insert(19);
        external_conditions.insert(22);
        external_conditions.insert(30);
        external_conditions.insert(35);
        external_conditions.insert(36);
        external_conditions.insert(39);
        external_conditions.insert(40);
        external_conditions.insert(41);
        external_conditions.insert(42);
        external_conditions.insert(45);
        external_conditions.insert(46);
        external_conditions.insert(54);
        external_conditions.insert(60);
        external_conditions.insert(63);
        external_conditions.insert(68);
        external_conditions.insert(69);
        external_conditions.insert(70);
        external_conditions.insert(492);
        Self {
            external_conditions,
        }
    }
}

impl ConditionEvaluator for PricatConditionEvaluatorFV2510 {
    fn message_type(&self) -> &str {
        "PRICAT"
    }

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

    fn evaluate(&self, condition: u32, ctx: &EvaluationContext) -> ConditionResult {
        match condition {
            1 => self.evaluate_1(ctx),
            2 => self.evaluate_2(ctx),
            3 => self.evaluate_3(ctx),
            4 => self.evaluate_4(ctx),
            5 => self.evaluate_5(ctx),
            6 => self.evaluate_6(ctx),
            7 => self.evaluate_7(ctx),
            8 => self.evaluate_8(ctx),
            9 => self.evaluate_9(ctx),
            10 => self.evaluate_10(ctx),
            12 => self.evaluate_12(ctx),
            14 => self.evaluate_14(ctx),
            19 => self.evaluate_19(ctx),
            22 => self.evaluate_22(ctx),
            24 => self.evaluate_24(ctx),
            26 => self.evaluate_26(ctx),
            27 => self.evaluate_27(ctx),
            28 => self.evaluate_28(ctx),
            29 => self.evaluate_29(ctx),
            30 => self.evaluate_30(ctx),
            31 => self.evaluate_31(ctx),
            32 => self.evaluate_32(ctx),
            33 => self.evaluate_33(ctx),
            34 => self.evaluate_34(ctx),
            35 => self.evaluate_35(ctx),
            36 => self.evaluate_36(ctx),
            37 => self.evaluate_37(ctx),
            38 => self.evaluate_38(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),
            44 => self.evaluate_44(ctx),
            45 => self.evaluate_45(ctx),
            46 => self.evaluate_46(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),
            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),
            490 => self.evaluate_490(ctx),
            491 => self.evaluate_491(ctx),
            492 => self.evaluate_492(ctx),
            494 => self.evaluate_494(ctx),
            495 => self.evaluate_495(ctx),
            502 => self.evaluate_502(ctx),
            503 => self.evaluate_503(ctx),
            504 => self.evaluate_504(ctx),
            511 => self.evaluate_511(ctx),
            512 => self.evaluate_512(ctx),
            513 => self.evaluate_513(ctx),
            519 => self.evaluate_519(ctx),
            520 => self.evaluate_520(ctx),
            521 => self.evaluate_521(ctx),
            522 => self.evaluate_522(ctx),
            902 => self.evaluate_902(ctx),
            908 => self.evaluate_908(ctx),
            909 => self.evaluate_909(ctx),
            911 => self.evaluate_911(ctx),
            912 => self.evaluate_912(ctx),
            926 => self.evaluate_926(ctx),
            929 => self.evaluate_929(ctx),
            931 => self.evaluate_931(ctx),
            932 => self.evaluate_932(ctx),
            933 => self.evaluate_933(ctx),
            937 => self.evaluate_937(ctx),
            939 => self.evaluate_939(ctx),
            940 => self.evaluate_940(ctx),
            941 => self.evaluate_941(ctx),
            942 => self.evaluate_942(ctx),
            946 => self.evaluate_946(ctx),
            948 => self.evaluate_948(ctx),
            949 => self.evaluate_949(ctx),
            957 => self.evaluate_957(ctx),
            959 => self.evaluate_959(ctx),
            968 => self.evaluate_968(ctx),
            _ => ConditionResult::Unknown,
        }
    }

    fn is_external(&self, condition: u32) -> bool {
        self.external_conditions.contains(&condition)
    }
    fn is_known(&self, condition: u32) -> bool {
        matches!(
            condition,
            1 | 2
                | 3
                | 4
                | 5
                | 6
                | 7
                | 8
                | 9
                | 10
                | 12
                | 14
                | 19
                | 22
                | 24
                | 26
                | 27
                | 28
                | 29
                | 30
                | 31
                | 32
                | 33
                | 34
                | 35
                | 36
                | 37
                | 38
                | 39
                | 40
                | 41
                | 42
                | 43
                | 44
                | 45
                | 46
                | 47
                | 48
                | 49
                | 50
                | 51
                | 52
                | 53
                | 54
                | 55
                | 56
                | 57
                | 60
                | 61
                | 62
                | 63
                | 64
                | 65
                | 66
                | 67
                | 68
                | 69
                | 70
                | 71
                | 72
                | 490
                | 491
                | 492
                | 494
                | 495
                | 502
                | 503
                | 504
                | 511
                | 512
                | 513
                | 519
                | 520
                | 521
                | 522
                | 902
                | 908
                | 909
                | 911
                | 912
                | 926
                | 929
                | 931
                | 932
                | 933
                | 937
                | 939
                | 940
                | 941
                | 942
                | 946
                | 948
                | 949
                | 957
                | 959
                | 968
        )
    }
}

impl PricatConditionEvaluatorFV2510 {
    /// [8] Wenn das in DE1001 angegebene Preisblatt vom NB nicht genutzt wird.
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_8(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("nb_does_not_use_price_list")
    }

    /// [10] Wenn eine weitere SG36 vorhanden ist, bei der sich der Inhalt von LIN DE7140 von LIN DE7140 dieser SG36 nur in der Ziffer nach dem letzten "-" unterscheidet und die Ziffer dort größer ist als in ...
    // REVIEW: Requires iterating all SG36 instances, extracting LIN DE7140 (elements[2][0]), splitting on the last '-', and checking whether any other SG36 has the same prefix with a strictly higher numeric suffix. This is the 'Gruppenartikel-ID / Artikel-ID' relationship. Group path SG17→SG36 based on PRICAT tx_group='SG17' from project knowledge. (medium confidence)
    fn evaluate_10(&self, ctx: &EvaluationContext) -> ConditionResult {
        let nav = match ctx.navigator() {
            Some(n) => n,
            None => return ConditionResult::Unknown,
        };
        let sg36_count = nav.group_instance_count(&["SG17", "SG36"]);
        if sg36_count < 2 {
            return ConditionResult::False;
        }
        // Collect all LIN DE7140 values from SG36 instances (elements[2][0])
        let mut lin_values: Vec<String> = Vec::new();
        for i in 0..sg36_count {
            let lin_segs = nav.find_segments_in_group("LIN", &["SG17", "SG36"], i);
            let val = lin_segs
                .first()
                .and_then(|s| s.elements.get(2))
                .and_then(|e| e.first())
                .cloned()
                .unwrap_or_default();
            lin_values.push(val);
        }
        // Check if any pair shares the prefix before the last '-'
        // with one having a strictly higher numeric suffix
        for i in 0..lin_values.len() {
            let a = &lin_values[i];
            if a.is_empty() {
                continue;
            }
            let Some(pos_a) = a.rfind('-') else {
                continue;
            };
            let prefix_a = &a[..pos_a];
            let Ok(num_a) = a[pos_a + 1..].parse::<u64>() else {
                continue;
            };
            for j in 0..lin_values.len() {
                if i == j {
                    continue;
                }
                let b = &lin_values[j];
                if b.is_empty() {
                    continue;
                }
                let Some(pos_b) = b.rfind('-') else {
                    continue;
                };
                let prefix_b = &b[..pos_b];
                let Ok(num_b) = b[pos_b + 1..].parse::<u64>() else {
                    continue;
                };
                if prefix_a == prefix_b && num_b > num_a {
                    return ConditionResult::True;
                }
            }
        }
        ConditionResult::False
    }

    /// [31] wenn BGM DE1001 = Z32 (Preisblatt Messstellenbetrieb)
    fn evaluate_31(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_segment_matching("BGM", &[(0, 0, "Z32")])
    }

    /// [34] wenn BGM DE1001 = Z77 (Preisblatt Konfigurationen)
    fn evaluate_34(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_segment_matching("BGM", &[(0, 0, "Z77")])
    }

    /// [35] Wenn das in DE1001 angegebene Preisblatt vom MSB nicht genutzt wird.
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_35(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("msb_does_not_use_price_list")
    }

    /// [44] Wenn BGM DE1001 = Z77, dann muss der hier genannte Zeitpunkt ≥ 01.10.2023 00:00 Uhr gesetzlicher deutscher Zeit sein
    // REVIEW: Checks BGM DE1001 == Z77, then validates DTM+137 (document date) >= 2023-10-01 00:00. 'Der hier genannte Zeitpunkt' refers to the timestamp field where this condition is annotated in the AHB; DTM+137 is assumed as the document date for PRICAT. Condition is inapplicable (Unknown) when BGM code is not Z77. German legal time threshold mapped to 202310010000 using dtm_ge string comparison on format 303. (medium confidence)
    fn evaluate_44(&self, ctx: &EvaluationContext) -> ConditionResult {
        let bgm_segs = ctx.find_segments("BGM");
        let is_z77 = bgm_segs
            .first()
            .and_then(|s| s.elements.first())
            .and_then(|e| e.first())
            .is_some_and(|v| v == "Z77");
        if !is_z77 {
            return ConditionResult::Unknown;
        }
        ctx.dtm_ge("137", "202310010000")
    }

    /// [45] Es sind nur Werte aus der EDI@Energy Codeliste der Artikelnummern und Artikel-ID erlaubt, die in dieser in Kapitel "Abrechnung Messstellenbetrieb für die Sparte Strom" für die jeweilige Marktroll...
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_45(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("artikel_messstellenbetrieb_strom")
    }

    /// [46] Es sind nur Werte aus der EDI@Energy Codeliste der Artikelnummern und Artikel-ID erlaubt, die in dieser in Kapitel "Artikel-ID für die Bestellprozesse beim MSB" genannt sind
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_46(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("artikel_bestellprozesse_msb")
    }

    /// [55] Wenn in dieser SG36 ein weiteres RNG (d. h. eine weitere Zone) vorhanden ist, in der der Wert des DE6162 (Wertebereichsgrenze, untere) größer ist als der Wert des DE6162 in diesem RNG
    // REVIEW: Each SG36 represents one price zone (one RNG). Collects DE6162 (lower range boundary) from RNG elements[1][1] (C280 component 1 = lower bound) across all SG36 instances under SG17. Condition is True if any zone has a strictly higher lower bound than another (min < max), meaning there exists a zone with higher DE6162 than the current minimum. Returns False if fewer than 2 zones or all lower bounds are equal. Group path SG17.SG36 follows PRICAT tx_group=SG17 convention. (medium confidence)
    fn evaluate_55(&self, ctx: &EvaluationContext) -> ConditionResult {
        let nav = match ctx.navigator() {
            Some(n) => n,
            None => return ConditionResult::Unknown,
        };
        let sg36_count = nav.group_instance_count(&["SG17", "SG36"]);
        let mut lower_bounds: Vec<f64> = Vec::new();
        for i in 0..sg36_count {
            let rng_segs = nav.find_segments_in_group("RNG", &["SG17", "SG36"], i);
            for rng in &rng_segs {
                // C280: [0]=unit, [1]=DE6162 lower bound, [2]=DE6163 upper bound
                if let Some(val) = rng.elements.get(1).and_then(|e| e.get(1)) {
                    if let Ok(n) = val.parse::<f64>() {
                        lower_bounds.push(n);
                    }
                }
            }
        }
        if lower_bounds.len() < 2 {
            return ConditionResult::False;
        }
        let min_val = lower_bounds.iter().cloned().fold(f64::INFINITY, f64::min);
        ConditionResult::from(lower_bounds.iter().any(|&v| v > min_val))
    }

    /// [56] Wenn BGM DE1001 = Z94, dann muss der hier genannte Zeitpunkt ≥ 01.10.2025 00:00 Uhr gesetzlicher deutscher Zeit sein
    // REVIEW: Checks BGM DE1001 == Z94, then validates DTM+137 (document date) >= 2025-10-01 00:00. Mirrors condition 44 pattern but for the Z94 document code introduced with FV2510 and the later threshold date. Condition is inapplicable (Unknown) when BGM code is not Z94. German legal time threshold 2025-10-01 00:00 mapped to 202510010000. (medium confidence)
    fn evaluate_56(&self, ctx: &EvaluationContext) -> ConditionResult {
        let bgm_segs = ctx.find_segments("BGM");
        let is_z94 = bgm_segs
            .first()
            .and_then(|s| s.elements.first())
            .and_then(|e| e.first())
            .is_some_and(|v| v == "Z94");
        if !is_z94 {
            return ConditionResult::Unknown;
        }
        ctx.dtm_ge("137", "202510010000")
    }

    /// [57] wenn BGM DE1001 = Z94 (Preisblatt Technik)
    fn evaluate_57(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualifier("BGM", 0, "Z94")
    }

    /// [60] Wenn in dieser SG36 der Teil vor dem "-" aus LIN DE7140 aus der Tabelle des Kapitels "Produkte zur Bestellung einer Änderung an einer Lokation in der Sparte Strom" der EDI@Energy Codeliste der Kon...
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_60(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external
            .evaluate("lin_product_code_is_lokationsaenderung_strom")
    }

    /// [61] Wenn in dieser SG36 der Wert der Zahl nach dem "-" aus LIN DE7140 &gt; 01
    // REVIEW: LIN DE7140 is elements[2][0]. The condition checks if the numeric part after '-' is greater than 01 (i.e., > 1). Uses group-scoped navigator for SG36 instances, falls back to message-wide on no navigator. Parses after the dash and compares as u32. (medium confidence)
    fn evaluate_61(&self, ctx: &EvaluationContext) -> ConditionResult {
        let nav = match ctx.navigator() {
            Some(n) => n,
            None => {
                let lin_segs = ctx.find_segments("LIN");
                for lin in &lin_segs {
                    if let Some(val) = lin.elements.get(2).and_then(|e| e.first()) {
                        if let Some(after_dash) = val.splitn(2, '-').nth(1) {
                            if let Ok(num) = after_dash.parse::<u32>() {
                                if num > 1 {
                                    return ConditionResult::True;
                                }
                            }
                        }
                    }
                }
                return ConditionResult::False;
            }
        };
        let sg36_count = nav.group_instance_count(&["SG36"]);
        for i in 0..sg36_count {
            let lin_segs = nav.find_segments_in_group("LIN", &["SG36"], i);
            for lin in &lin_segs {
                if let Some(val) = lin.elements.get(2).and_then(|e| e.first()) {
                    if let Some(after_dash) = val.splitn(2, '-').nth(1) {
                        if let Ok(num) = after_dash.parse::<u32>() {
                            if num > 1 {
                                return ConditionResult::True;
                            }
                        }
                    }
                }
            }
        }
        ConditionResult::False
    }

    /// [62] Wenn IMD+F vorhanden
    fn evaluate_62(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualifier("IMD", 0, "F")
    }

    /// [63] Wenn vorheriges DE7008 zur Beschreibung der Leistung dieser Artikel-ID nicht ausreicht
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_63(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external
            .evaluate("previous_imd_description_insufficient")
    }

    /// [65] wenn in dieser SG36 der Teil des Codes in LIN DE7140 nach dem "-" von "01" abweicht
    // REVIEW: Checks if the part of LIN DE7140 (elements[2][0]) after '-' differs from '01'. Iterates SG36 instances via navigator; falls back to message-wide LIN scan. Returns True if any SG36 contains a LIN where the suffix is not '01'. (medium confidence)
    fn evaluate_65(&self, ctx: &EvaluationContext) -> ConditionResult {
        let nav = match ctx.navigator() {
            Some(n) => n,
            None => {
                let lins = ctx.find_segments("LIN");
                let found = lins.iter().any(|s| {
                    s.elements
                        .get(2)
                        .and_then(|e| e.first())
                        .and_then(|code| code.split_once('-'))
                        .map(|(_, suffix)| suffix != "01")
                        .unwrap_or(false)
                });
                return ConditionResult::from(found);
            }
        };
        let sg36_count = nav.group_instance_count(&["SG17", "SG36"]);
        for i in 0..sg36_count {
            let lins = nav.find_segments_in_group("LIN", &["SG17", "SG36"], i);
            for lin in &lins {
                if let Some(code) = lin.elements.get(2).and_then(|e| e.first()) {
                    if code
                        .split_once('-')
                        .map(|(_, suffix)| suffix != "01")
                        .unwrap_or(false)
                    {
                        return ConditionResult::True;
                    }
                }
            }
        }
        ConditionResult::False
    }

    /// [66] wenn im DE7140 des LIN dieser SG36 der Teil des Codes nach dem "-" den Wert 02 hat, muss dieses DE = 0 sein und in allen anderen RNG zu Artikel-ID, bei denen der Teil des Codes vor dem "-" mit dem ...
    // REVIEW: Two-part check on RNG DE6162 (lower bound) for SG36 instances whose LIN DE7140 has the suffix "02": (1) the current "02"-SG36's DE6162 must equal "0"; (2) every other SG36 sharing the LIN prefix must have its DE6162 match some other matching-prefix SG36's DE6152 (upper bound) — i.e., a chain-continuity check. RNG sits in child group SG40 under SG36; DE6162 = elements[1][1], DE6152 = elements[1][2] (same positions used in the already-working [72]).
    fn evaluate_66(&self, ctx: &EvaluationContext) -> ConditionResult {
        let nav = match ctx.navigator() {
            Some(n) => n,
            None => return ConditionResult::Unknown,
        };
        let sg36_count = nav.group_instance_count(&["SG36"]);
        if sg36_count == 0 {
            return ConditionResult::Unknown;
        }

        struct Sg36 {
            prefix: String,
            suffix: String,
            lower: Option<String>,
            upper: Option<String>,
        }

        let collected: Vec<Sg36> = (0..sg36_count)
            .map(|i| {
                let lin_val = nav
                    .find_segments_in_group("LIN", &["SG36"], i)
                    .first()
                    .and_then(|s| s.elements.get(2))
                    .and_then(|e| e.first())
                    .cloned()
                    .unwrap_or_default();
                let (prefix, suffix) = lin_val
                    .split_once('-')
                    .map(|(p, s)| (p.to_string(), s.to_string()))
                    .unwrap_or_default();
                let sg40_count = nav.child_group_instance_count(&["SG36"], i, "SG40");
                let mut lower: Option<String> = None;
                let mut upper: Option<String> = None;
                for j in 0..sg40_count {
                    let rngs = nav.find_segments_in_child_group("RNG", &["SG36"], i, "SG40", j);
                    if let Some(rng) = rngs.first() {
                        if lower.is_none() {
                            lower = rng
                                .elements
                                .get(1)
                                .and_then(|e| e.get(1))
                                .filter(|v| !v.is_empty())
                                .cloned();
                        }
                        if upper.is_none() {
                            upper = rng
                                .elements
                                .get(1)
                                .and_then(|e| e.get(2))
                                .filter(|v| !v.is_empty())
                                .cloned();
                        }
                    }
                    if lower.is_some() && upper.is_some() {
                        break;
                    }
                }
                Sg36 {
                    prefix,
                    suffix,
                    lower,
                    upper,
                }
            })
            .collect();

        // No trigger ("02"-suffix SG36) in the message → condition does not apply.
        if !collected.iter().any(|s| s.suffix == "02") {
            return ConditionResult::Unknown;
        }

        for (t_idx, trigger) in collected
            .iter()
            .enumerate()
            .filter(|(_, s)| s.suffix == "02")
        {
            // (1) The trigger's own lower bound must be "0".
            match &trigger.lower {
                Some(v) if v == "0" => {}
                _ => return ConditionResult::False,
            }
            // (2) Every OTHER matching-prefix SG36's lower bound must equal
            //     some DIFFERENT matching-prefix SG36's upper bound.
            let matching: Vec<(usize, &Sg36)> = collected
                .iter()
                .enumerate()
                .filter(|(_, s)| s.prefix == trigger.prefix)
                .collect();
            for (o_idx, other) in &matching {
                if *o_idx == t_idx {
                    continue;
                }
                let lower = match &other.lower {
                    Some(v) => v.as_str(),
                    None => return ConditionResult::False,
                };
                let found_chain = matching
                    .iter()
                    .filter(|(x_idx, _)| *x_idx != *o_idx)
                    .any(|(_, x)| x.upper.as_deref() == Some(lower));
                if !found_chain {
                    return ConditionResult::False;
                }
            }
        }
        ConditionResult::True
    }

    /// [67] wenn in dieser SG17 ein weiteres LIN vorhanden ist, in dem der Teil des Codes vor dem "-" des DE7140 mit dem des DE7140 des LIN dieser SG36 identisch ist und in dem der Wert nach dem "-" um eins gr...
    // REVIEW: Iterates all SG17 instances and collects (prefix, suffix) pairs from LIN DE7140 across all their child SG36 instances. For each code, checks whether another LIN in the same SG17 has the same prefix and a numerically incremented suffix (preserving leading-zero width). Returns True if such a consecutive pair exists. (medium confidence)
    fn evaluate_67(&self, ctx: &EvaluationContext) -> ConditionResult {
        let nav = match ctx.navigator() {
            Some(n) => n,
            None => return ConditionResult::Unknown,
        };
        let sg17_count = nav.group_instance_count(&["SG17"]);
        for sg17_i in 0..sg17_count {
            let sg36_count = nav.child_group_instance_count(&["SG17"], sg17_i, "SG36");
            let mut code_parts: Vec<(String, String)> = Vec::new();
            for sg36_i in 0..sg36_count {
                let lins =
                    nav.find_segments_in_child_group("LIN", &["SG17"], sg17_i, "SG36", sg36_i);
                for lin in &lins {
                    if let Some(code) = lin.elements.get(2).and_then(|e| e.first()) {
                        if let Some((prefix, suffix)) = code.split_once('-') {
                            code_parts.push((prefix.to_string(), suffix.to_string()));
                        }
                    }
                }
            }
            for (prefix, suffix) in &code_parts {
                if let Ok(n) = suffix.parse::<u32>() {
                    let next = n + 1;
                    let width = suffix.len();
                    let next_str = format!("{:0width$}", next, width = width);
                    if code_parts
                        .iter()
                        .any(|(p, s)| p == prefix && s == &next_str)
                    {
                        return ConditionResult::True;
                    }
                }
            }
        }
        ConditionResult::False
    }

    /// [68] Der Teil des Codes vor dem "-" muss ein Messprodukt-Code sein
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_68(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("is_messprodukt_code")
    }

    /// [69] Der Teil des Codes vor dem "-" muss ein Konfigurationsprodukt-Code sein
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_69(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("is_konfigurationsprodukt_code")
    }

    /// [70] Der Teil des Codes vor dem "-" muss ein Produkt-Code sein
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_70(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("lin_prefix_is_valid_product_code")
    }

    /// [71] Es muss der Code 9991000003030-01 sein
    fn evaluate_71(&self, ctx: &EvaluationContext) -> ConditionResult {
        let segs = ctx.find_segments("LIN");
        if segs.is_empty() {
            return ConditionResult::Unknown;
        }
        let matches = segs.iter().any(|s| {
            s.elements
                .get(2)
                .and_then(|e| e.first())
                .is_some_and(|v| v == "9991000003030-01")
        });
        ConditionResult::from(matches)
    }

    /// [72] Wenn in dieser SG36 die letzte Ziffer von LIN DE7140 &gt;1 ist, dann muss es eine SG36 geben dessen Inhalt von LIN DE7140 sich von dem in dieser SG36 nur in der letzten Ziffer unterscheidet und in ...
    // REVIEW: Cross-SG36 interval continuity check: for each SG36 whose LIN DE7140 ends with digit > 1, there must be another SG36 with DE7140 differing only in the last digit, and that SG36's RNG DE6152 (upper bound, elements[1][2]) must equal this SG36's RNG DE6162 (lower bound, elements[1][1]). RNG is in child group SG40 under SG36. Implemented via navigator with parent-child navigation. Medium confidence due to complexity of cross-group interval continuity logic. (medium confidence)
    fn evaluate_72(&self, ctx: &EvaluationContext) -> ConditionResult {
        let nav = match ctx.navigator() {
            Some(n) => n,
            None => return ConditionResult::Unknown,
        };
        let sg36_count = nav.group_instance_count(&["SG36"]);
        if sg36_count == 0 {
            return ConditionResult::Unknown;
        }
        for i in 0..sg36_count {
            let lin_segs = nav.find_segments_in_group("LIN", &["SG36"], i);
            let lin_val = match lin_segs
                .first()
                .and_then(|s| s.elements.get(2))
                .and_then(|e| e.first())
                .filter(|v| !v.is_empty())
            {
                Some(v) => v.clone(),
                None => continue,
            };
            let last_digit = match lin_val.chars().last().and_then(|c| c.to_digit(10)) {
                Some(d) => d,
                None => continue,
            };
            if last_digit <= 1 {
                continue;
            }
            // Get this SG36's RNG DE6162 (lower bound) from child SG40
            let sg40_count = nav.child_group_instance_count(&["SG36"], i, "SG40");
            let mut this_lower: Option<String> = None;
            for j in 0..sg40_count {
                let rngs = nav.find_segments_in_child_group("RNG", &["SG36"], i, "SG40", j);
                if let Some(rng) = rngs.first() {
                    if let Some(lower) = rng.elements.get(1).and_then(|e| e.get(1)) {
                        if !lower.is_empty() {
                            this_lower = Some(lower.clone());
                            break;
                        }
                    }
                }
            }
            let this_lower = match this_lower {
                Some(v) => v,
                None => continue,
            };
            let lin_prefix = &lin_val[..lin_val.len() - 1];
            let mut found = false;
            for k in 0..sg36_count {
                if k == i {
                    continue;
                }
                let lin_segs_k = nav.find_segments_in_group("LIN", &["SG36"], k);
                let lin_val_k = match lin_segs_k
                    .first()
                    .and_then(|s| s.elements.get(2))
                    .and_then(|e| e.first())
                    .filter(|v| !v.is_empty())
                {
                    Some(v) => v.clone(),
                    None => continue,
                };
                if lin_val_k.len() != lin_val.len() {
                    continue;
                }
                if &lin_val_k[..lin_val_k.len() - 1] != lin_prefix {
                    continue;
                }
                // Check RNG DE6152 (upper bound) in that SG36's SG40
                let sg40_count_k = nav.child_group_instance_count(&["SG36"], k, "SG40");
                for j in 0..sg40_count_k {
                    let rngs_k = nav.find_segments_in_child_group("RNG", &["SG36"], k, "SG40", j);
                    if let Some(rng_k) = rngs_k.first() {
                        if let Some(upper_k) = rng_k.elements.get(1).and_then(|e| e.get(2)) {
                            if upper_k == &this_lower {
                                found = true;
                                break;
                            }
                        }
                    }
                }
                if found {
                    break;
                }
            }
            if !found {
                return ConditionResult::False;
            }
        }
        ConditionResult::True
    }

    /// [511] Hinweis: 1. Der genannte Wert gehört nicht zum Intervall.  2. Die untere Wertegrenze zu der Artikel-ID, deren Zahl an der letzten Stelle den Wert n hat, muss kleiner sein, als die untere Wertegren...
    fn evaluate_511(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: 1. Der genannte Wert gehört nicht zum Intervall.
        // 2. Die untere Wertegrenze zu der Artikel-ID, deren Zahl an der letzten Stelle den Wert n hat,
        // muss kleiner sein, als die untere Wertegrenze zu der Artikel-ID, deren Zahl an der letzten
        // Stelle den Wert n+1 hat. — informational annotation, always applies
        ConditionResult::True
    }

    /// [522] Hinweis: Hier ist die Leistung zu beschreiben, die mit dieser Artikel-ID in Rechnung gestellt wird, wobei darauf zu achten ist, dass zu erkennen ist, wie sich diese von den Leistungen unterscheiden...
    fn evaluate_522(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Hier ist die Leistung zu beschreiben, die mit dieser Artikel-ID in Rechnung gestellt
        // wird, wobei darauf zu achten ist, dass zu erkennen ist, wie sich diese von den Leistungen
        // unterscheiden, bei denen die ersten 13 Stellen der Artikel-ID mit den ersten 13 Stellen
        // dieser Artikel-ID identisch sind. — informational annotation, always applies
        ConditionResult::True
    }

    /// [1] Wenn Vorgängerversion vorhanden
    /// EXTERNAL: Requires context from outside the message.
    // REVIEW: Whether a Vorgängerversion (predecessor version) exists is a business context question — it depends on whether a prior PRICAT was sent for the same catalog/articles and is tracked outside the EDIFACT message itself. Cannot be determined from the current message content alone. (medium confidence)
    fn evaluate_1(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("previous_version_exists")
    }

    /// [2] Wenn in dieser SG36 LIN in DE7140 9990001000813 vorhanden
    fn evaluate_2(&self, ctx: &EvaluationContext) -> ConditionResult {
        // HAND-EDITED: "in dieser/derselben SG36" — scoped to the enclosing group.
        let values = ctx.this_group_values("LIN", 2, 0, &["SG36"]);
        ConditionResult::from(values.iter().any(|(_, v)| v == "9990001000813"))
    }

    /// [3] Wenn IMD+X vorhanden
    fn evaluate_3(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualifier("IMD", 0, "X")
    }

    /// [4] Wenn SG36 IMD+C in diesem IMD vorhanden
    fn evaluate_4(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("IMD", 0, "C", &["SG36"])
    }

    /// [5] Wenn SG36 IMD+X in diesem IMD vorhanden
    fn evaluate_5(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.any_group_has_qualifier("IMD", 0, "X", &["SG36"])
    }

    /// [6] Wenn in dieser SG36 LIN in DE7140 9990001000798 vorhanden
    fn evaluate_6(&self, ctx: &EvaluationContext) -> ConditionResult {
        // HAND-EDITED: "in dieser/derselben SG36" — scoped to the enclosing group.
        let values = ctx.this_group_values("LIN", 2, 0, &["SG36"]);
        ConditionResult::from(values.iter().any(|(_, v)| v == "9990001000798"))
    }

    /// [7] Wenn in dieser SG36 LIN in DE7140 9990001000798 nicht vorhanden
    fn evaluate_7(&self, ctx: &EvaluationContext) -> ConditionResult {
        // HAND-EDITED: "in dieser/derselben SG36" — scoped to the enclosing group.
        let values = ctx.this_group_values("LIN", 2, 0, &["SG36"]);
        ConditionResult::from(!values.iter().any(|(_, v)| v == "9990001000798"))
    }

    /// [9] Wenn BGM DE1373 =11 nicht vorhanden
    fn evaluate_9(&self, ctx: &EvaluationContext) -> ConditionResult {
        match ctx.find_segment("BGM") {
            None => ConditionResult::False, // segment absent → condition not applicable
            Some(seg) => {
                let val = seg
                    .elements
                    .get(4)
                    .and_then(|e| e.first())
                    .map(|s| s.as_str())
                    .unwrap_or("");
                ConditionResult::from(val != "11")
            }
        }
    }

    /// [12] je UNB ist nur eine Nachricht mit BGM+Z04 in der Übertragungsdatei erlaubt (nur eine Nachricht je Übertragungsdatei)
    // REVIEW: The notation-resolved hint says elements[0]=Z04. BGM C002.DE1001 is at elements[0][0]. has_qualifier checks elements[0][0]=='Z04'. The 'only one per UNB' structural constraint is an AHB rule consuming this condition — within a single message, we can only check if this IS a Z04 message type. (medium confidence)
    fn evaluate_12(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualifier("BGM", 0, "Z04")
    }

    /// [14] je UNB ist maximal je Code aus DE1001 eine Nachricht in der Übertragungsdatei erlaubt
    /// EXTERNAL: Requires context from outside the message.
    // REVIEW: This is a transmission-level cardinality constraint: per UNB envelope, at most one message per DE1001 message type code is allowed. Enforcing this requires visibility into all messages within the same UNB envelope, which is outside the scope of evaluating a single message's EvaluationContext. Must be handled externally at the interchange/envelope level. (medium confidence)
    fn evaluate_14(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("max_one_message_per_type_in_unb")
    }

    /// [19] Nur MP-ID aus Sparte Strom
    /// EXTERNAL: Requires context from outside the message.
    // REVIEW: Nur MP-ID aus Sparte Strom — checking whether a market participant ID belongs to the electricity (Strom) sector requires a lookup against an external market participant registry (Marktstammdatenregister or similar). The sector classification cannot be derived from the EDIFACT message content alone. (medium confidence)
    fn evaluate_19(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("mp_id_is_strom_sector")
    }

    /// [22] Wenn die Artikel-ID aus dieser SG36 LIN DE7140 in der EDI@Energy Codeliste der Artikelnummern und Artikel-ID in der Spalte "PRICAT Preisangabe" ein X hat
    /// EXTERNAL: Requires context from outside the message.
    // REVIEW: This condition requires a lookup of the Artikel-ID from LIN DE7140 (elements[2][0]) against the EDI@Energy code list of article numbers, specifically checking whether the 'PRICAT Preisangabe' column has an X for that entry. Code list membership checks against external EDI@Energy publications cannot be determined from EDIFACT message content alone — they require an external code list resolver. (medium confidence)
    fn evaluate_22(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("article_id_has_pricat_price_flag")
    }

    /// [24] Wenn in dieser SG36 Wert von LIN DE7140 im Format n1-n2-n1-n8-n2-n1
    fn evaluate_24(&self, ctx: &EvaluationContext) -> ConditionResult {
        // HAND-EDITED: "in dieser/derselben SG36" — scoped to the enclosing group.
        let values = ctx.this_group_values("LIN", 2, 0, &["SG36"]);
        ConditionResult::from(values.iter().any(|(_, val)| {
            let parts: Vec<&str> = val.split('-').collect();
            if parts.len() != 6 {
                return false;
            }
            let expected_lens = [1usize, 2, 1, 8, 2, 1];
            parts
                .iter()
                .zip(expected_lens.iter())
                .all(|(p, &len)| p.len() == len && p.chars().all(|ch| ch.is_ascii_digit()))
        }))
    }

    /// [26] Wenn BGM DE1001 = Z70 vorhanden
    fn evaluate_26(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualifier("BGM", 0, "Z70")
    }

    /// [27] Wenn BGM DE1001 = Z70 nicht vorhanden
    fn evaluate_27(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.lacks_qualifier("BGM", 0, "Z70")
    }

    /// [28] Wenn die zugehörige Artikel-ID in der letzten Stelle eine 1 ist
    // REVIEW: Checks the last character of the article ID (Artikel-ID) in the PIA segment. The PIA segment's additional product identification is at elements[1][0]. Last digit '1' → True, any other digit → False. Medium confidence because the exact PIA element path for Artikel-ID in PRICAT is assumed from convention; no segment structure reference provided. (medium confidence)
    fn evaluate_28(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Wenn die zugehörige Artikel-ID in der letzten Stelle eine 1 ist
        // Artikel-ID is in PIA segment, elements[1][0]
        let segs = ctx.find_segments("PIA");
        match segs
            .first()
            .and_then(|s| s.elements.get(1))
            .and_then(|e| e.first())
        {
            Some(val) => match val.chars().last() {
                Some('1') => ConditionResult::True,
                Some(c) if c.is_ascii_digit() => ConditionResult::False,
                Some(_) => ConditionResult::False,
                None => ConditionResult::False, // segment absent → condition not applicable
            },
            None => ConditionResult::False, // segment absent → condition not applicable
        }
    }

    /// [29] Wenn die zugehörige Artikel-ID in der letzten Stelle &gt; 1 ist
    // REVIEW: Checks the last character of the article ID in PIA elements[1][0]. Last digit > '1' (i.e., '2'–'9') → True, last digit <= '1' → False. Same assumptions as condition 28 regarding PIA element path. (medium confidence)
    fn evaluate_29(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Wenn die zugehörige Artikel-ID in der letzten Stelle > 1 ist
        // Artikel-ID is in PIA segment, elements[1][0]
        let segs = ctx.find_segments("PIA");
        match segs
            .first()
            .and_then(|s| s.elements.get(1))
            .and_then(|e| e.first())
        {
            Some(val) => match val.chars().last() {
                Some(c) if c.is_ascii_digit() && c > '1' => ConditionResult::True,
                Some(c) if c.is_ascii_digit() => ConditionResult::False,
                Some(_) => ConditionResult::False,
                None => ConditionResult::False, // segment absent → condition not applicable
            },
            None => ConditionResult::False, // segment absent → condition not applicable
        }
    }

    /// [30] wenn MP-ID in SG2 NAD+MR in der Rolle LF
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_30(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("recipient_is_lf")
    }

    /// [32] wenn der Zeitpunkt im DTM+157 DE2380 &lt; 01.01.2024 00:00 Uhr gesetzlicher deutscher Zeit
    // REVIEW: DTM+157 (Gültigkeitsbeginn) has DE2380 at elements[0][1] in format 303 (YYYYMMDDHHMM). String comparison is valid for this zero-padded numeric format. Assumes German local time encoding as per EDI@Energy convention. Returns Unknown if DTM+157 is absent. (medium confidence)
    fn evaluate_32(&self, ctx: &EvaluationContext) -> ConditionResult {
        {
            let dtms = ctx.find_segments_with_qualifier("DTM", 0, "157");
            match dtms.first() {
                Some(dtm) => {
                    match dtm
                        .elements
                        .first()
                        .and_then(|e| e.get(1))
                        .map(|s| s.as_str())
                    {
                        Some(value) if !value.is_empty() => {
                            // Format 303: YYYYMMDDHHMM — string comparison valid for numeric date strings
                            // 01.01.2024 00:00 German legal time → "202401010000"
                            ConditionResult::from(value < "202401010000")
                        }
                        _ => ConditionResult::Unknown,
                    }
                }
                None => ConditionResult::False, // segment absent → condition not applicable
            }
        }
    }

    /// [33] wenn der Zeitpunkt im DTM+157 DE2380 ≥ 01.01.2024 00:00 Uhr gesetzlicher deutscher Zeit
    // REVIEW: Mirror of condition 32 with >= comparison. DTM+157 DE2380 at elements[0][1], format 303. Returns Unknown if segment absent. (medium confidence)
    fn evaluate_33(&self, ctx: &EvaluationContext) -> ConditionResult {
        {
            let dtms = ctx.find_segments_with_qualifier("DTM", 0, "157");
            match dtms.first() {
                Some(dtm) => {
                    match dtm
                        .elements
                        .first()
                        .and_then(|e| e.get(1))
                        .map(|s| s.as_str())
                    {
                        Some(value) if !value.is_empty() => {
                            // Format 303: YYYYMMDDHHMM — string comparison valid for numeric date strings
                            // 01.01.2024 00:00 German legal time → "202401010000"
                            ConditionResult::from(value >= "202401010000")
                        }
                        _ => ConditionResult::Unknown,
                    }
                }
                None => ConditionResult::False, // segment absent → condition not applicable
            }
        }
    }

    /// [36] Wenn MP-ID in SG2 NAD+MR in der Rolle NB
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_36(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("recipient_is_nb")
    }

    /// [37] Wenn im DE3155 in demselben COM der Code EM vorhanden ist
    // REVIEW: COM segment C076 has DE3148 (number) at elements[0][0] and DE3155 (channel code) at elements[0][1]. The condition checks if DE3155 == "EM" (email). COM segment structure is standard EDIFACT and not ambiguous despite not being in the provided reference. 'Demselben COM' at message level means any COM with EM qualifier. (medium confidence)
    fn evaluate_37(&self, ctx: &EvaluationContext) -> ConditionResult {
        {
            let coms = ctx.find_segments("COM");
            ConditionResult::from(coms.iter().any(|s| {
                s.elements
                    .first()
                    .and_then(|e| e.get(1))
                    .is_some_and(|v| v == "EM")
            }))
        }
    }

    /// [38] Wenn im DE3155 in demselben COM der Code TE / FX / AJ / AL vorhanden ist
    // REVIEW: Same COM segment structure as condition 37. Checks DE3155 for any of TE (telephone), FX (fax), AJ, AL channel codes. (medium confidence)
    fn evaluate_38(&self, ctx: &EvaluationContext) -> ConditionResult {
        {
            let coms = ctx.find_segments("COM");
            ConditionResult::from(coms.iter().any(|s| {
                s.elements
                    .first()
                    .and_then(|e| e.get(1))
                    .is_some_and(|v| matches!(v.as_str(), "TE" | "FX" | "AJ" | "AL"))
            }))
        }
    }

    /// [39] Es sind nur Werte aus der EDI@Energy Codeliste der Artikelnummern und Artikel-ID erlaubt, die in der Spalte MaBiS ein X haben
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_39(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("article_id_in_mabis_codelist")
    }

    /// [40] Es sind nur Werte aus der EDI@Energy Codeliste der Artikelnummern und Artikel-ID erlaubt, die in der Spalte H ein X haben
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_40(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("article_id_in_h_codelist")
    }

    /// [41] Es sind nur Werte aus der EDI@Energy Codeliste der Artikelnummern und Artikel-ID erlaubt, die in der Spalte "PRICAT Codeverwendung" ein X haben
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_41(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("article_id_in_pricat_codelist")
    }

    /// [42] Es sind nur Werte erlaubt, die die Bildungsvorschrift der EDI@Energy Codeliste der Artikelnummern und Artikel-ID erfüllen, und die in der Spalte "PRICAT Codeverwendung" ein X haben
    /// EXTERNAL: Requires context from outside the message.
    fn evaluate_42(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external
            .evaluate("article_id_valid_pricat_formation_rule")
    }

    /// [43] Wenn BGM DE1001 = Z32 und LIN DE7140 im Format n1-n2-n1-n3, dann muss der hier genannte Zeitpunkt ≥ 01.01.2024 00:00 Uhr gesetzlicher deutscher Zeit sein
    // REVIEW: Checks BGM DE1001==Z32, LIN DE7140 contains hyphens (n1-n2-n1-n3 format like '1-01-6-005'), and DTM+157 (Gültigkeitsbeginn) >= 20240101. Medium confidence because 'der hier genannte Zeitpunkt' is assumed to be DTM+157. (medium confidence)
    fn evaluate_43(&self, ctx: &EvaluationContext) -> ConditionResult {
        let bgm = match ctx.find_segment("BGM") {
            Some(s) => s,
            None => return ConditionResult::Unknown,
        };
        if bgm
            .elements
            .first()
            .and_then(|e| e.first())
            .map(|s| s.as_str())
            != Some("Z32")
        {
            return ConditionResult::False;
        }
        let lin_segments = ctx.find_segments("LIN");
        let has_hyphen_format = lin_segments.iter().any(|s| {
            s.elements
                .get(2)
                .and_then(|e| e.first())
                .map_or(false, |v| v.contains('-'))
        });
        if !has_hyphen_format {
            return ConditionResult::False;
        }
        let dtm_segs = ctx.find_segments_with_qualifier("DTM", 0, "157");
        match dtm_segs.first() {
            Some(dtm) => {
                let value = dtm
                    .elements
                    .first()
                    .and_then(|e| e.get(1))
                    .map(|s| s.as_str())
                    .unwrap_or("");
                if value.len() >= 8 {
                    ConditionResult::from(&value[..8] >= "20240101")
                } else {
                    ConditionResult::Unknown
                }
            }
            None => ConditionResult::False, // segment absent → condition not applicable
        }
    }

    /// [47] Wenn BGM DE1001 = Z32 und LIN DE7140 im Format n13, dann muss der hier genannte Zeitpunkt &lt; 01.01.2024 00:00 Uhr gesetzlicher deutscher Zeit sein
    // REVIEW: Checks BGM DE1001==Z32, LIN DE7140 is exactly 13 digits with no hyphens (legacy EAN/GLN format), and DTM+157 < 20240101. Complement of condition 43. (medium confidence)
    fn evaluate_47(&self, ctx: &EvaluationContext) -> ConditionResult {
        let bgm = match ctx.find_segment("BGM") {
            Some(s) => s,
            None => return ConditionResult::Unknown,
        };
        if bgm
            .elements
            .first()
            .and_then(|e| e.first())
            .map(|s| s.as_str())
            != Some("Z32")
        {
            return ConditionResult::False;
        }
        let lin_segments = ctx.find_segments("LIN");
        let has_n13_format = lin_segments.iter().any(|s| {
            s.elements
                .get(2)
                .and_then(|e| e.first())
                .map_or(false, |v| {
                    !v.contains('-') && v.len() == 13 && v.chars().all(|c| c.is_ascii_digit())
                })
        });
        if !has_n13_format {
            return ConditionResult::False;
        }
        let dtm_segs = ctx.find_segments_with_qualifier("DTM", 0, "157");
        match dtm_segs.first() {
            Some(dtm) => {
                let value = dtm
                    .elements
                    .first()
                    .and_then(|e| e.get(1))
                    .map(|s| s.as_str())
                    .unwrap_or("");
                if value.len() >= 8 {
                    ConditionResult::from(&value[..8] < "20240101")
                } else {
                    ConditionResult::Unknown
                }
            }
            None => ConditionResult::False, // segment absent → condition not applicable
        }
    }

    /// [48] Wenn in dieser SG36 LIN in DE7140 einer der Codes 1-01-6-005 / 1-01-9-001 / 1-01-9-002 / 1-02-0-015 / 1-03-8-001 / 1-03-8-002 / 1-03-8-003 / 1-03-8-004 / 1-03-9-001 / 1-03-9-002 / 1-03-9-003 / 1-03...
    fn evaluate_48(&self, ctx: &EvaluationContext) -> ConditionResult {
        // HAND-EDITED: "in dieser/derselben SG36" — scoped to the enclosing group.
        const CODES: &[&str] = &[
            "1-01-6-005",
            "1-01-9-001",
            "1-01-9-002",
            "1-02-0-015",
            "1-03-8-001",
            "1-03-8-002",
            "1-03-8-003",
            "1-03-8-004",
            "1-03-9-001",
            "1-03-9-002",
            "1-03-9-003",
            "1-03-9-004",
            "1-07-4-001",
        ];
        let lin_segments = ctx.scoped_find_segments_in("SG36", "LIN");
        ConditionResult::from(lin_segments.iter().any(|s| {
            s.elements
                .get(2)
                .and_then(|e| e.first())
                .map_or(false, |v| CODES.contains(&v.as_str()))
        }))
    }

    /// [49] Wenn in dieser SG36 LIN in DE7140 keiner der Codes 1-01-6-005 / 1-01-9-001 / 1-01-9-002 / 1-02-0-015 / 1-03-8-001 / 1-03-8-002 / 1-03-8-003 / 1-03-8-004 / 1-03-9-001 / 1-03-9-002 / 1-03-9-003 / 1-0...
    fn evaluate_49(&self, ctx: &EvaluationContext) -> ConditionResult {
        // HAND-EDITED: "in dieser/derselben SG36" — scoped to the enclosing group.
        const CODES: &[&str] = &[
            "1-01-6-005",
            "1-01-9-001",
            "1-01-9-002",
            "1-02-0-015",
            "1-03-8-001",
            "1-03-8-002",
            "1-03-8-003",
            "1-03-8-004",
            "1-03-9-001",
            "1-03-9-002",
            "1-03-9-003",
            "1-03-9-004",
            "1-07-4-001",
        ];
        let lin_segments = ctx.scoped_find_segments_in("SG36", "LIN");
        ConditionResult::from(!lin_segments.iter().any(|s| {
            s.elements
                .get(2)
                .and_then(|e| e.first())
                .map_or(false, |v| CODES.contains(&v.as_str()))
        }))
    }

    /// [50] Wenn MP-ID aus RFF+Z56 mit MP-ID aus NAD+MS identisch ist
    fn evaluate_50(&self, ctx: &EvaluationContext) -> ConditionResult {
        let rff_segs = ctx.find_segments_with_qualifier("RFF", 0, "Z56");
        let nad_segs = ctx.find_segments_with_qualifier("NAD", 0, "MS");
        let rff_mp_id = rff_segs
            .first()
            .and_then(|s| s.elements.first())
            .and_then(|e| e.get(1))
            .map(|s| s.as_str());
        let nad_mp_id = nad_segs
            .first()
            .and_then(|s| s.elements.get(1))
            .and_then(|e| e.first())
            .map(|s| s.as_str());
        match (rff_mp_id, nad_mp_id) {
            (Some(rff), Some(nad)) if !rff.is_empty() && !nad.is_empty() => {
                ConditionResult::from(rff == nad)
            }
            _ => ConditionResult::Unknown,
        }
    }

    /// [51] Wenn BGM+Z54 vorhanden
    fn evaluate_51(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.has_qualifier("BGM", 0, "Z54")
    }

    /// [52] Wenn BGM+Z54 nicht vorhanden
    fn evaluate_52(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.lacks_qualifier("BGM", 0, "Z54")
    }

    /// [53] Diese SG40 darf genau einmal in der SG36 angegeben werden
    // REVIEW: Validates that SG40 appears exactly once within each SG36 instance. Uses the group navigator to count child SG40 instances per SG36 parent. PRICAT tx_group is SG17; SG36 is a nested group within SG17. Falls back to Unknown when no navigator is available. Medium confidence because the exact parent path ["SG17", "SG36"] is inferred from PRICAT structure conventions without an explicit segment reference. (medium confidence)
    fn evaluate_53(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Diese SG40 darf genau einmal in der SG36 angegeben werden
        // For each SG36 instance, verify SG40 appears exactly once as a child group
        let nav = match ctx.navigator() {
            Some(n) => n,
            None => return ConditionResult::Unknown,
        };
        let sg36_count = nav.group_instance_count(&["SG17", "SG36"]);
        if sg36_count == 0 {
            return ConditionResult::Unknown;
        }
        for i in 0..sg36_count {
            let sg40_count = nav.child_group_instance_count(&["SG17", "SG36"], i, "SG40");
            if sg40_count != 1 {
                return ConditionResult::False;
            }
        }
        ConditionResult::True
    }

    /// [54] Falls der Preis des Artikels gezont ist
    /// EXTERNAL: Requires context from outside the message.
    // REVIEW: 'Falls der Preis des Artikels gezont ist' describes whether the article has zone-based pricing — a product/business configuration attribute. While zone pricing might leave structural traces in the message (multiple zone segments), whether a price is fundamentally 'gezont' is a business model characteristic of the article that is external to the EDIFACT message content itself. (medium confidence)
    fn evaluate_54(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("article_price_is_zoned")
    }

    /// [64] Wenn der Zeitpunkt im DTM+157 DE2380 ≥ 01.01.2026, 00:00 Uhr gesetzlicher deutscher Zeit
    fn evaluate_64(&self, ctx: &EvaluationContext) -> ConditionResult {
        let dtm_segs = ctx.find_segments_with_qualifier("DTM", 0, "157");
        match dtm_segs.first() {
            Some(dtm) => {
                let value = dtm
                    .elements
                    .first()
                    .and_then(|e| e.get(1))
                    .map(|s| s.as_str())
                    .unwrap_or("");
                if value.len() >= 8 {
                    ConditionResult::from(&value[..8] >= "20260101")
                } else {
                    ConditionResult::Unknown
                }
            }
            None => ConditionResult::False, // segment absent → condition not applicable
        }
    }

    /// [490] wenn Wert in diesem DE, an der Stelle CCYYMMDD ein Datum aus dem angegeben Zeitraum der Tabelle Kapitel 3.5 „Prozesszeitpunkt bei MESZ mit UTC“ ist
    fn evaluate_490(&self, ctx: &EvaluationContext) -> ConditionResult {
        match ctx.resolved_value {
            Some(val) => is_mesz_utc(val),
            None => ConditionResult::False,
        }
    }

    /// [491] wenn Wert in diesem DE, an der Stelle CCYYMMDD ein Datum aus dem angegeben Zeitraum der Tabelle Kapitel 3.6 „Prozesszeitpunkt bei MEZ mit UTC“ ist
    fn evaluate_491(&self, ctx: &EvaluationContext) -> ConditionResult {
        match ctx.resolved_value {
            Some(val) => is_mez_utc(val),
            None => ConditionResult::False,
        }
    }

    /// [492] wenn MP-ID in NAD+MR aus Sparte Strom
    /// EXTERNAL: Requires context from outside the message.
    // REVIEW: Checks if the NAD+MR market participant ID belongs to the electricity (Strom) sector. Sector membership cannot be determined from the EDIFACT message alone — requires external business context. (medium confidence)
    fn evaluate_492(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.external.evaluate("recipient_is_strom")
    }

    /// [494] Das hier genannte Datum muss der Zeitpunkt sein, zu dem das Dokument erstellt wurde, oder ein Zeitpunkt, der davor liegt
    fn evaluate_494(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: Das hier genannte Datum muss der Zeitpunkt sein, zu dem das Dokument
        // erstellt wurde, oder ein Zeitpunkt, der davor liegt. Informational annotation
        // about the semantic meaning of the date field — always applies unconditionally.
        ConditionResult::True
    }

    /// [495] Der Zeitpunkt muss ≤ dem Wert im DE2380 des DTM+137 sein
    // REVIEW: The condition checks that the Betrachtungszeitintervall (DTM+492) value is <= the Nachrichtendatum (DTM+137) value. Both DTM qualifiers appear in the segment reference for PRICAT. We extract DTM+137's DE2380 value as the threshold and use dtm_le to compare. Medium confidence because 'Der Zeitpunkt' could refer to DTM+157 (Gültigkeitsbeginn) instead of DTM+492 — the exact field being validated is not explicit in the description. (medium confidence)
    fn evaluate_495(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Der Zeitpunkt (DTM+492 Betrachtungszeitintervall) muss <= DTM+137 (Nachrichtendatum) sein
        let dtm_137_segs = ctx.find_segments_with_qualifier("DTM", 0, "137");
        let dtm_137 = match dtm_137_segs.first() {
            Some(s) => s,
            None => return ConditionResult::Unknown,
        };
        let threshold = match dtm_137.elements.first().and_then(|e| e.get(1)) {
            Some(v) => v.clone(),
            None => return ConditionResult::Unknown,
        };
        ctx.dtm_le("492", &threshold)
    }

    /// [502] Hinweis: Preis in Euro je MWh
    fn evaluate_502(&self, _ctx: &EvaluationContext) -> ConditionResult {
        ConditionResult::True
    }

    /// [503] Hinweis: Hier ist immer der Wert 1000 einzutragen, da in DE5118 der Preis in €/MWh angegeben wird.
    fn evaluate_503(&self, _ctx: &EvaluationContext) -> ConditionResult {
        ConditionResult::True
    }

    /// [504] Hinweis: Dokumentennummer der PRICAT
    fn evaluate_504(&self, _ctx: &EvaluationContext) -> ConditionResult {
        ConditionResult::True
    }

    /// [512] Hinweis: Der genannte Wert gehört zum Intervall
    fn evaluate_512(&self, _ctx: &EvaluationContext) -> ConditionResult {
        ConditionResult::True
    }

    /// [513] Hinweis: Die zum Preis gehörende Einheit ist in der Codeliste definiert
    fn evaluate_513(&self, _ctx: &EvaluationContext) -> ConditionResult {
        ConditionResult::True
    }

    /// [519] Hinweis: Es darf nur eine Information im DE3148 übermittelt werden
    fn evaluate_519(&self, _ctx: &EvaluationContext) -> ConditionResult {
        ConditionResult::True
    }

    /// [520] Hinweis: Falls der Preis des Artikels gezont ist, ist diese SG40 so oft zu wiederholen, bis alle Preise zu diesem Artikel genannt sind
    fn evaluate_520(&self, _ctx: &EvaluationContext) -> ConditionResult {
        ConditionResult::True
    }

    /// [521] Hinweis: Je Artikel-ID muss in einem RNG der Wert dieses DE = 0 sein und in allen anderen RNG zu dieser Artikel-ID muss der Wert dieses DE mit dem Wert des DE6152 eines anderen RNG zu dieser Artike...
    fn evaluate_521(&self, _ctx: &EvaluationContext) -> ConditionResult {
        // Hinweis: informational annotation about RNG DE value relationships — one RNG must have value 0,
        // all others must equal DE6152 of another RNG for the same Artikel-ID
        ConditionResult::True
    }

    /// [902] Format: Möglicher Wert: ≥ 0
    fn evaluate_902(&self, _ctx: &EvaluationContext) -> ConditionResult {
        ConditionResult::True
    }

    /// [908] Format: Mögliche Werte: 1 bis n
    fn evaluate_908(&self, _ctx: &EvaluationContext) -> ConditionResult {
        ConditionResult::True
    }

    /// [909] Format: Mögliche Werte: 0 bis n
    // REVIEW: Format condition specifying possible values 0 to n (non-negative). Applied to LIN DE1082 (Positionsnummer) as the most likely numeric element in PRICAT that can take values starting from 0. Medium confidence because the AHB context specifying which exact element this condition applies to is not included in the description. (medium confidence)
    fn evaluate_909(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Format: Mögliche Werte 0 bis n — numeric value must be >= 0
        // Applied to LIN DE1082 (Positionsnummer) which can start from 0
        let lin_segs = ctx.find_segments("LIN");
        if lin_segs.is_empty() {
            return ConditionResult::Unknown;
        }
        for seg in &lin_segs {
            let val = match seg.elements.first().and_then(|e| e.first()) {
                Some(v) => v,
                None => return ConditionResult::Unknown,
            };
            match validate_numeric(val, ">=", 0.0) {
                ConditionResult::False => return ConditionResult::False,
                ConditionResult::Unknown => return ConditionResult::Unknown,
                ConditionResult::True => {}
            }
        }
        ConditionResult::True
    }

    /// [911] Format: Mögliche Werte: 1 bis n, je Nachricht oder Segmentgruppe bei 1 beginnend und fortlaufend aufsteigend
    // REVIEW: Format condition specifying values 1 to n, starting at 1 and continuously ascending per message or segment group. This describes sequential position numbering, which in PRICAT is DE1082 in the LIN segment. The implementation collects all LIN segments and verifies their position numbers are 1, 2, 3, ... in order. Medium confidence because the specific element and scope (per-message vs per-SG17 group) are not explicit in the condition description alone. (medium confidence)
    fn evaluate_911(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Format: Mögliche Werte 1 bis n, sequential per message/segment group starting at 1
        // Validates LIN DE1082 (Positionsnummer) is sequential starting from 1
        let lin_segs = ctx.find_segments("LIN");
        if lin_segs.is_empty() {
            return ConditionResult::Unknown;
        }
        let mut expected: u64 = 1;
        for seg in &lin_segs {
            let pos_str = match seg.elements.first().and_then(|e| e.first()) {
                Some(v) => v,
                None => return ConditionResult::Unknown,
            };
            let pos: u64 = match pos_str.parse() {
                Ok(n) => n,
                Err(_) => return ConditionResult::False,
            };
            if pos != expected {
                return ConditionResult::False;
            }
            expected += 1;
        }
        ConditionResult::True
    }

    /// [912] Format: max. 6 Nachkommastellen
    // REVIEW: Max 6 decimal places format check. In PRICAT context, price values (PRI segment, element 0, component 1) are the primary numeric values with decimal places. Medium confidence because the exact segment this applies to depends on context — it could also apply to QTY or other numeric fields. (medium confidence)
    fn evaluate_912(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.format_check("PRI", 0, 1, |val| validate_max_decimal_places(val, 6))
    }

    /// [926] Format: Möglicher Wert: 0
    // REVIEW: Value must be exactly 0. Applies to a numeric data element — QTY is most common in PRICAT for this kind of constraint (e.g., minimum order quantity of 0). Medium confidence because the specific segment depends on where this condition is referenced in the AHB. (medium confidence)
    fn evaluate_926(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.format_check("QTY", 0, 1, |val| validate_numeric(val, "==", 0.0))
    }

    /// [929] Format: Möglicher Wert: 1000
    // REVIEW: Value must be exactly 1000. In PRICAT, 1000 is a common reference quantity (e.g., price per 1000 units in QTY). Medium confidence because the exact target segment depends on where this condition is used in the AHB. (medium confidence)
    fn evaluate_929(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.format_check("QTY", 0, 1, |val| validate_numeric(val, "==", 1000.0))
    }

    /// [931] Format: ZZZ = +00
    // REVIEW: DTM timezone check: EDIFACT DTM format 303 (CCYYMMDDHHMMzzz) or 719 encodes timezone offset. The condition requires ZZZ=+00 (UTC offset). elements[0][1] holds the datetime value string; checking it ends with '+00' covers standard EDIFACT timezone encoding. Medium confidence because the exact DTM qualifier and format code context is unknown without the segment structure reference. (medium confidence)
    fn evaluate_931(&self, ctx: &EvaluationContext) -> ConditionResult {
        // ZZZ = +00: timezone offset in DTM value must be +00
        // DTM format 303: YYYYMMDDHHMMzzz, timezone encoded as last part of elements[0][1]
        let dtm_segments = ctx.find_segments("DTM");
        for seg in &dtm_segments {
            if let Some(value) = seg.elements.first().and_then(|e| e.get(1)) {
                if !value.is_empty() {
                    // Timezone +00 appears at end of value string
                    if value.ends_with("+00") {
                        return ConditionResult::True;
                    } else {
                        return ConditionResult::False;
                    }
                }
            }
        }
        ConditionResult::Unknown
    }

    /// [932] Format: HHMM = 2200
    // REVIEW: DTM time check: extracts HHMM portion from DTM value. Format 203 (CCYYMMDDHHmm) places hours at positions 8-11. Format 401 (HHmm) starts at position 0. Condition requires exactly 2200. Medium confidence because the specific DTM qualifier context in PRICAT is unknown without the segment structure reference. (medium confidence)
    fn evaluate_932(&self, ctx: &EvaluationContext) -> ConditionResult {
        // HHMM = 2200: time value in DTM must be 2200
        // In DTM format 203 (YYYYMMDDHHMM) or 401 (HHMM), the time portion is HHMM
        let dtm_segments = ctx.find_segments("DTM");
        for seg in &dtm_segments {
            if let Some(value) = seg.elements.first().and_then(|e| e.get(1)) {
                let format_code = seg
                    .elements
                    .first()
                    .and_then(|e| e.get(2))
                    .map(|s| s.as_str())
                    .unwrap_or("");
                let time_part = match format_code {
                    "203" if value.len() >= 12 => &value[8..12],
                    "401" if value.len() >= 4 => &value[0..4],
                    _ if value.len() >= 12 => &value[8..12],
                    _ => continue,
                };
                if time_part == "2200" {
                    return ConditionResult::True;
                } else {
                    return ConditionResult::False;
                }
            }
        }
        ConditionResult::Unknown
    }

    /// [933] Format: HHMM = 2300
    // REVIEW: Same structure as condition 932 but checks for 2300 instead of 2200. Extracts HHMM portion from DTM value using format code to determine position. (medium confidence)
    fn evaluate_933(&self, ctx: &EvaluationContext) -> ConditionResult {
        // HHMM = 2300: time value in DTM must be 2300
        let dtm_segments = ctx.find_segments("DTM");
        for seg in &dtm_segments {
            if let Some(value) = seg.elements.first().and_then(|e| e.get(1)) {
                let format_code = seg
                    .elements
                    .first()
                    .and_then(|e| e.get(2))
                    .map(|s| s.as_str())
                    .unwrap_or("");
                let time_part = match format_code {
                    "203" if value.len() >= 12 => &value[8..12],
                    "401" if value.len() >= 4 => &value[0..4],
                    _ if value.len() >= 12 => &value[8..12],
                    _ => continue,
                };
                if time_part == "2300" {
                    return ConditionResult::True;
                } else {
                    return ConditionResult::False;
                }
            }
        }
        ConditionResult::Unknown
    }

    /// [937] Format: keine Nachkommastelle
    // REVIEW: No decimal places allowed — integer values only. Implemented as validate_max_decimal_places with 0. In PRICAT, this typically applies to QTY (quantity must be whole number). Medium confidence because the exact target segment depends on AHB context. (medium confidence)
    fn evaluate_937(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.format_check("QTY", 0, 1, |val| validate_max_decimal_places(val, 0))
    }

    /// [939] Format: Die Zeichenkette muss die Zeichen @ und . enthalten
    // REVIEW: Email address format validation: the string must contain both '@' and '.'. This pattern matches COM segment (communication address) with channel code EM (Electronic Mail). elements[0][0] holds the address, elements[0][1] holds the channel qualifier. Checks channel=EM first, then falls back to any non-empty COM value. Medium confidence because PRICAT segment structure reference not provided. (medium confidence)
    fn evaluate_939(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Email format: string must contain both '@' and '.'
        // Typically applies to COM segment (communication channel EM = email)
        let com_segments = ctx.find_segments("COM");
        for seg in &com_segments {
            // COM: elements[0][0] = communication address, elements[0][1] = channel code
            let channel = seg
                .elements
                .first()
                .and_then(|e| e.get(1))
                .map(|s| s.as_str())
                .unwrap_or("");
            if channel == "EM" {
                if let Some(address) = seg.elements.first().and_then(|e| e.first()) {
                    let contains_at = address.contains('@');
                    let contains_dot = address.contains('.');
                    return ConditionResult::from(contains_at && contains_dot);
                }
            }
        }
        // Fallback: check any COM value for @ and .
        for seg in &com_segments {
            if let Some(address) = seg.elements.first().and_then(|e| e.first()) {
                if !address.is_empty() {
                    return ConditionResult::from(address.contains('@') && address.contains('.'));
                }
            }
        }
        ConditionResult::Unknown
    }

    /// [940] Format: Die Zeichenkette muss mit dem Zeichen + beginnen und danach dürfen nur noch Ziffern folgen
    // REVIEW: Phone number format: must start with '+' then only digits (international E.164 format). Applies to COM segment with telephone/fax channel codes (TE, FX, AJ). elements[0][0] = number, elements[0][1] = channel code. Medium confidence because PRICAT segment structure reference not provided. (medium confidence)
    fn evaluate_940(&self, ctx: &EvaluationContext) -> ConditionResult {
        // Phone number format: must start with '+' followed only by digits
        // Typically applies to COM segment (TEL/FAX channel)
        let com_segments = ctx.find_segments("COM");
        for seg in &com_segments {
            let channel = seg
                .elements
                .first()
                .and_then(|e| e.get(1))
                .map(|s| s.as_str())
                .unwrap_or("");
            if matches!(channel, "TE" | "FX" | "AJ") {
                if let Some(number) = seg.elements.first().and_then(|e| e.first()) {
                    if !number.is_empty() {
                        let valid = number.starts_with('+')
                            && number.len() > 1
                            && number[1..].chars().all(|c| c.is_ascii_digit());
                        return ConditionResult::from(valid);
                    }
                }
            }
        }
        // Fallback: check any COM value for +digit format
        for seg in &com_segments {
            if let Some(number) = seg.elements.first().and_then(|e| e.first()) {
                if !number.is_empty() {
                    let valid = number.starts_with('+')
                        && number.len() > 1
                        && number[1..].chars().all(|c| c.is_ascii_digit());
                    return ConditionResult::from(valid);
                }
            }
        }
        ConditionResult::Unknown
    }

    /// [941] Format: Artikelnummer
    // REVIEW: Article number format validation on PIA segment (Additional Product ID), element 1, component 0. The pattern n1-n2-n1-n3 is a common PRICAT Artikelnummer format in the German energy market. Medium confidence because the exact digit-segment pattern may differ — should be verified against the specific AHB table for this condition reference. (medium confidence)
    fn evaluate_941(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.format_check("PIA", 1, 0, |val| {
            validate_artikel_pattern(val, &[1, 2, 1, 3])
        })
    }

    /// [942] Format: n1-n2-n1-n3
    fn evaluate_942(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.format_check("PIA", 1, 0, |val| {
            validate_artikel_pattern(val, &[1, 2, 1, 3])
        })
    }

    /// [946] Format: max. 11 Nachkommastellen
    // REVIEW: Format: max. 11 Nachkommastellen — validates that a numeric value has at most 11 decimal places. In PRICAT, price values appear in PRI segment element 0 component 1. Using PRI as the most likely price segment in PRICAT context. (medium confidence)
    fn evaluate_946(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.format_check("PRI", 0, 1, |val| validate_max_decimal_places(val, 11))
    }

    /// [948] Format: n1-n2-n1-n8-n2
    fn evaluate_948(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.format_check("PIA", 1, 0, |val| {
            validate_artikel_pattern(val, &[1, 2, 1, 8, 2])
        })
    }

    /// [949] Format: n1-n2-n1-n8-n2-n1
    fn evaluate_949(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.format_check("PIA", 1, 0, |val| {
            validate_artikel_pattern(val, &[1, 2, 1, 8, 2, 1])
        })
    }

    /// [957] Format: n1-n2-n1-n8
    fn evaluate_957(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.format_check("PIA", 1, 0, |val| {
            validate_artikel_pattern(val, &[1, 2, 1, 8])
        })
    }

    /// [959] Format: n13-n2
    // REVIEW: Format: n13-n2 is an Artikelnummer pattern — 13 digits, dash, 2 digits. In PRICAT, article identifiers appear in PIA element 1 component 0. Using validate_artikel_pattern with &[13, 2]. Medium confidence because the exact target segment/element depends on AHB context not provided here. (medium confidence)
    fn evaluate_959(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.format_check("PIA", 1, 0, |val| validate_artikel_pattern(val, &[13, 2]))
    }

    /// [968] Format: Möglicher Wert: ≤ 0
    // REVIEW: Format: Möglicher Wert: ≤ 0 means the numeric value must be less than or equal to zero. In PRICAT, PRI segment element 0 component 1 holds the price amount. Using validate_numeric with "<=", 0.0. Medium confidence because the exact target segment depends on AHB context — could also be MOA or another numeric field. (medium confidence)
    fn evaluate_968(&self, ctx: &EvaluationContext) -> ConditionResult {
        ctx.format_check("PRI", 0, 1, |val| validate_numeric(val, "<=", 0.0))
    }
}