dsv7-parser 7.0.0

data/lib/dsv7/validator/schemas/base.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Dsv7
+  class Validator
+    class SchemaBase
+      def initialize(result)
+        @result = result
+      end
+
+      def validate_element(name, attrs, line_number)
+        schema = self.class::SCHEMAS[name]
+        return unless schema
+
+        check_count(name, attrs, schema.length, line_number)
+        validate_attribute_types(name, attrs, schema, line_number)
+        validate_cross_rules(name, attrs, line_number) if respond_to?(:validate_cross_rules, true)
+      end
+
+      private
+
+      def validate_attribute_types(name, attrs, schema, line_number)
+        schema.each_with_index do |spec, i|
+          type, required, opts = spec
+          val = attrs[i]
+
+          if (val.nil? || val.empty?) && required
+            add_error("Element #{name}: missing required attribute #{i + 1} (line #{line_number})")
+            next
+          end
+          next if val.nil? || val.empty?
+
+          send("check_#{type}", name, i + 1, val, line_number, opts)
+        end
+      end
+
+      def add_error(msg)
+        @result.add_error(msg)
+      end
+
+      def check_count(name, attrs, expected, line_number)
+        got = attrs.length
+        return if got == expected
+
+        add_error(
+          "Element #{name}: expected #{expected} attributes, got #{got} (line #{line_number})"
+        )
+      end
+    end
+  end
+end

data/lib/dsv7/validator/schemas/erg_schema.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative '../types'
+require_relative 'base'
+
+module Dsv7
+  class Validator
+    # Validates Wettkampfergebnisliste attribute counts and datatypes
+    class ErgSchema < SchemaBase
+      include WkTypeChecks
+
+      SCHEMAS = {
+        'ERZEUGER' => [[:zk, true], [:zk, true], [:zk, true]],
+        'VERANSTALTUNG' => [[:zk, true], [:zk, true], [:bahnl, true], [:zeitmessung, true]],
+        'VERANSTALTER' => [[:zk, true]],
+        'AUSRICHTER' => [
+          [:zk, true], [:zk, true], [:zk, false], [:zk, false], [:zk, false],
+          [:land, false], [:zk, false], [:zk, false], [:zk, true]
+        ],
+        'ABSCHNITT' => [[:zahl, true], [:datum, true], [:uhrzeit, true], [:relativ, false]],
+        'KAMPFGERICHT' => [[:zahl, true], [:zk, true], [:zk, true], [:zk, true]],
+        'WETTKAMPF' => [
+          [:zahl, true], [:wk_art_erg, true], [:zahl, true], [:zahl, false],
+          [:einzelstrecke, true], [:technik, true], [:ausuebung, true],
+          [:geschlecht_wk, true], [:bestenliste, true], [:zahl, false], [:wk_art, false]
+        ],
+        'WERTUNG' => [
+          [:zahl, true], [:wk_art, true], [:zahl, true], [:wert_typ, true],
+          [:jgak, true], [:jgak, false], [:geschlecht_erw, false], [:zk, true]
+        ],
+        'VEREIN' => [[:zk, true], [:zahl, true], [:zahl, true], [:land, true]],
+        'PNERGEBNIS' => [
+          [:zahl, true], [:wk_art_erg, true], [:zahl, true], [:zahl, true],
+          [:zk, false], [:zk, true], [:zahl, true], [:zahl, true],
+          [:geschlecht_pf, true], [:zahl, true], [:zahl, false], [:zk, true],
+          [:zahl, true], [:zeit, true], [:zk, false], [:nachtrag_flag, false],
+          [:land, false], [:land, false], [:land, false]
+        ],
+        'PNZWISCHENZEIT' => [
+          [:zahl, true], [:zahl, true], [:wk_art_erg, true], [:zahl, true], [:zeit, true]
+        ],
+        'PNREAKTION' => [
+          [:zahl, true], [:zahl, true], [:wk_art_erg, true], [:reaktion_art, false], [:zeit, true]
+        ],
+        # Accept both names as they appear across sources
+        'STAFFELERGEBNIS' => [
+          [:zahl, true], [:wk_art_erg, true], [:zahl, true], [:zahl, true],
+          [:zk, false], [:zahl, true], [:zahl, true], [:zk, true], [:zahl, true],
+          [:zeit, true], [:zahl, false], [:zk, false], [:nachtrag_flag, false]
+        ],
+        'STERGEBNIS' => [
+          [:zahl, true], [:wk_art_erg, true], [:zahl, true], [:zahl, true],
+          [:zk, false], [:zahl, true], [:zahl, true], [:zk, true], [:zahl, true],
+          [:zeit, true], [:zahl, false], [:zk, false], [:nachtrag_flag, false]
+        ],
+        'STAFFELPERSON' => [
+          [:zahl, true], [:zahl, true], [:wk_art_erg, true], [:zk, true],
+          [:zahl, true], [:zahl, true], [:geschlecht_pf, true], [:zahl, true],
+          [:zahl, false], [:land, false], [:land, false], [:land, false]
+        ],
+        'STZWISCHENZEIT' => [
+          [:zahl, true], [:zahl, true], [:wk_art_erg, true], [:zahl, true], [:zahl, true],
+          [:zeit, true]
+        ],
+        'STABLOESE' => [
+          [:zahl, true], [:zahl, true], [:wk_art_erg, true], [:zahl, true],
+          [:reaktion_art, false], [:zeit, true]
+        ]
+      }.freeze
+    end
+  end
+end

data/lib/dsv7/validator/schemas/vml_schema.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../types'
+require_relative 'base'
+
+module Dsv7
+  class Validator
+    # Validates Vereinsmeldeliste attribute counts and datatypes
+    class VmlSchema < SchemaBase
+      include WkTypeChecks
+
+      SCHEMAS = {
+        'ERZEUGER' => [[:zk, true], [:zk, true], [:zk, true]],
+        'VERANSTALTUNG' => [[:zk, true], [:zk, true], [:bahnl, true], [:zeitmessung, true]],
+        'ABSCHNITT' => [[:zahl, true], [:datum, true], [:uhrzeit, true], [:relativ, false]],
+        'WETTKAMPF' => [
+          [:zahl, true], [:wk_art, true], [:zahl, true], [:zahl, false],
+          [:einzelstrecke, true], [:technik, true], [:ausuebung, true],
+          [:geschlecht_wk, true], [:zahl, false], [:wk_art, false]
+        ],
+        'VEREIN' => [[:zk, true], [:zahl, true], [:zahl, true], [:land, true]],
+        'ANSPRECHPARTNER' => [
+          [:zk, true], [:zk, false], [:zk, false], [:zk, false],
+          [:land, false], [:zk, false], [:zk, false], [:zk, true]
+        ],
+        'KARIMELDUNG' => [[:zahl, true], [:zk, true], [:zk, true]],
+        'KARIABSCHNITT' => [[:zahl, true], [:zahl, true], [:zk, false]],
+        'TRAINER' => [[:zahl, true], [:zk, true]],
+        'PNMELDUNG' => [
+          [:zk, true], [:zahl, true], [:zahl, true], [:geschlecht_pf, true],
+          [:zahl, true], [:zahl, false], [:zahl, false],
+          [:land, false], [:land, false], [:land, false]
+        ],
+        'HANDICAP' => [
+          [:zahl, true], [:zk, false], [:zk, false],
+          [:zk, true], [:zk, true], [:zk, true], [:zk, false]
+        ],
+        'STARTPN' => [[:zahl, true], [:zahl, true], [:zeit, false]],
+        'STMELDUNG' => [
+          [:zahl, true], [:zahl, true], [:wert_typ, true],
+          [:jgak, true], [:jgak, false], [:zk, false]
+        ],
+        'STARTST' => [[:zahl, true], [:zahl, true], [:zeit, false]],
+        'STAFFELPERSON' => [[:zahl, true], [:zahl, true], [:zahl, true], [:zahl, true]]
+      }.freeze
+
+      # no extra cross-rules for VML currently
+    end
+  end
+end

data/lib/dsv7/validator/schemas/vrl_schema.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../types'
+require_relative 'base'
+
+module Dsv7
+  class Validator
+    # Validates Vereinsergebnisliste attribute counts and datatypes
+    class VrlSchema < SchemaBase
+      include WkTypeChecks
+
+      SCHEMAS = {
+        'ERZEUGER' => [[:zk, true], [:zk, true], [:zk, true]],
+        'VERANSTALTUNG' => [[:zk, true], [:zk, true], [:bahnl, true], [:zeitmessung, true]],
+        'VERANSTALTER' => [[:zk, true]],
+        'AUSRICHTER' => [
+          [:zk, true], [:zk, true], [:zk, false], [:zk, false], [:zk, false],
+          [:land, false], [:zk, false], [:zk, false], [:zk, true]
+        ],
+        'ABSCHNITT' => [[:zahl, true], [:datum, true], [:uhrzeit, true], [:relativ, false]],
+        'KAMPFGERICHT' => [[:zahl, true], [:zk, true], [:zk, true], [:zk, true]],
+        'WETTKAMPF' => [
+          [:zahl, true], [:wk_art_erg, true], [:zahl, true], [:zahl, false],
+          [:einzelstrecke, true], [:technik, true], [:ausuebung, true],
+          [:geschlecht_wk, true], [:bestenliste, true], [:zahl, false], [:wk_art, false]
+        ],
+        'WERTUNG' => [
+          [:zahl, true], [:wk_art, true], [:zahl, true], [:wert_typ, true],
+          [:jgak, true], [:jgak, false], [:geschlecht_erw, false], [:zk, true]
+        ],
+        'VEREIN' => [[:zk, true], [:zahl, true], [:zahl, true], [:land, true]],
+        'PERSON' => [
+          [:zk, true], [:zahl, true], [:zahl, true], [:geschlecht_pf, true],
+          [:zahl, true], [:zahl, false], [:land, false], [:land, false], [:land, false]
+        ],
+        'PERSONENERGEBNIS' => [
+          [:zahl, true], [:zahl, true], [:wk_art_erg, true], [:zahl, true],
+          [:zahl, true], [:zeit, true], [:nichtwertung_grund, false],
+          [:zk, false], [:nachtrag_flag, false]
+        ],
+        'PNZWISCHENZEIT' => [
+          [:zahl, true], [:zahl, true], [:wk_art_erg, true], [:zahl, true], [:zeit, true]
+        ],
+        'PNREAKTION' => [
+          [:zahl, true], [:zahl, true], [:wk_art_erg, true], [:reaktion_art, false], [:zeit, true]
+        ],
+        'STAFFEL' => [
+          [:zahl, true], [:zahl, true], [:wert_typ, true],
+          [:jgak, true], [:jgak, false]
+        ],
+        'STAFFELPERSON' => [
+          [:zahl, true], [:zahl, true], [:wk_art_erg, true], [:zk, true],
+          [:zahl, true], [:zahl, true], [:geschlecht_pf, true], [:zahl, true],
+          [:zahl, false], [:land, false], [:land, false], [:land, false]
+        ],
+        'STAFFELERGEBNIS' => [
+          [:zahl, true], [:zahl, true], [:wk_art_erg, true], [:zahl, true],
+          [:zahl, true], [:zeit, true], [:zk, false], [:zahl, false],
+          [:zk, false], [:nachtrag_flag, false]
+        ],
+        # Accept both names as they appear across sources
+        'STERGEBNIS' => [
+          [:zahl, true], [:zahl, true], [:wk_art_erg, true], [:zahl, true],
+          [:zahl, true], [:zeit, true], [:zk, false], [:zahl, false],
+          [:zk, false], [:nachtrag_flag, false]
+        ],
+        'STZWISCHENZEIT' => [
+          [:zahl, true], [:zahl, true], [:wk_art_erg, true], [:zahl, true], [:zahl, true],
+          [:zeit, true]
+        ],
+        'STABLOESE' => [
+          [:zahl, true], [:zahl, true], [:wk_art_erg, true], [:zahl, true],
+          [:reaktion_art, false], [:zeit, true]
+        ]
+      }.freeze
+    end
+  end
+end

data/lib/dsv7/validator/schemas/wk_schema.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative '../types'
+require_relative 'base'
+
+module Dsv7
+  class Validator
+    # Validates Wettkampfdefinitionsliste attribute counts and datatypes
+    class WkSchema < SchemaBase
+      include WkTypeChecks
+
+      SCHEMAS = {
+        'ERZEUGER' => [[:zk, true], [:zk, true], [:zk, true]],
+        'VERANSTALTUNG' => [
+          [:zk, true], [:zk, true], [:bahnl, true], [:zeitmessung, true]
+        ],
+        'VERANSTALTUNGSORT' => [
+          [:zk, true], [:zk, false], [:zk, false], [:zk, true],
+          [:land, true], [:zk, false], [:zk, false], [:zk, false]
+        ],
+        'AUSSCHREIBUNGIMNETZ' => [[:zk, false]],
+        'VERANSTALTER' => [[:zk, true]],
+        'AUSRICHTER' => [
+          [:zk, true], [:zk, true], [:zk, false], [:zk, false], [:zk, false],
+          [:land, false], [:zk, false], [:zk, false], [:zk, true]
+        ],
+        'MELDEADRESSE' => [
+          [:zk, true], [:zk, false], [:zk, false], [:zk, false],
+          [:land, false], [:zk, false], [:zk, false], [:zk, true]
+        ],
+        'MELDESCHLUSS' => [[:datum, true], [:uhrzeit, true]],
+        'BANKVERBINDUNG' => [[:zk, false], [:zk, true], [:zk, false]],
+        'BESONDERES' => [[:zk, true]],
+        'NACHWEIS' => [[:datum, true], [:datum, false], [:nachweis_bahn, true]],
+        'ABSCHNITT' => [
+          [:zahl, true], [:datum, true], [:uhrzeit, false],
+          [:uhrzeit, false], [:uhrzeit, true], [:relativ, false]
+        ],
+        'WETTKAMPF' => [
+          [:zahl, true], [:wk_art, true], [:zahl, true], [:zahl, false],
+          [:einzelstrecke, true], [:technik, true], [:ausuebung, true],
+          [:geschlecht_wk, true], [:bestenliste, true], [:zahl, false], [:wk_art, false]
+        ],
+        'WERTUNG' => [
+          [:zahl, true], [:wk_art, true], [:zahl, true], [:wert_typ, true],
+          [:jgak, true], [:jgak, false], [:geschlecht_erw, false], [:zk, true]
+        ],
+        # Intentionally omitting PFLICHTZEIT for now (spec examples appear inconsistent)
+        'MELDEGELD' => [[:meldegeld_typ, true], [:betrag, true], [:zahl, false]]
+      }.freeze
+
+      def validate_cross_rules(name, attrs, line_number)
+        return unless name == 'MELDEGELD'
+
+        type_str = attrs[0].to_s.upcase
+        needs_wk = type_str == 'WKMELDEGELD' && (attrs[2].nil? || attrs[2].empty?)
+        return unless needs_wk
+
+        add_error(
+          "Element MELDEGELD: 'WKMELDEGELD' requires Wettkampfnr (attr 3) (line #{line_number})"
+        )
+      end
+    end
+  end
+end

data/lib/dsv7/validator/types/common.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Dsv7
+  class Validator
+    module WkTypeChecksCommon
+      def check_zk(_name, _index, _val, _line_number, _opts = nil)
+        # any string (already UTF-8 scrubbed); nothing to do
+      end
+
+      def check_zahl(name, idx, val, line_number, _opts = nil)
+        return if val.match?(/^\d+$/)
+
+        add_error(invalid_zahl_error(name, idx, val, line_number))
+      end
+
+      def check_betrag(name, idx, val, line_number, _opts = nil)
+        return if val.match?(/^\d+,\d{2}$/)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Betrag '#{val}' (expected x,yy) " \
+          "(line #{line_number})"
+        )
+      end
+
+      def check_einzelstrecke(name, idx, val, line_number, _opts = nil)
+        return add_error(invalid_zahl_error(name, idx, val, line_number)) unless val.match?(/^\d+$/)
+
+        n = val.to_i
+        return if n.zero? || (1..25_000).cover?(n)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: Einzelstrecke out of range '#{val}' " \
+          "(allowed 1..25000 or 0) (line #{line_number})"
+        )
+      end
+
+      def invalid_zahl_error(name, idx, val, line_number)
+        "Element #{name}, attribute #{idx}: invalid Zahl '#{val}' (line #{line_number})"
+      end
+    end
+  end
+end

data/lib/dsv7/validator/types/datetime.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Dsv7
+  class Validator
+    module WkTypeChecksDateTime
+      def check_datum(name, idx, val, line_number, _opts = nil)
+        return add_error(datum_format_error(name, idx, val, line_number)) unless
+          val.match?(/^\d{2}\.\d{2}\.\d{4}$/)
+
+        Date.strptime(val, '%d.%m.%Y')
+      rescue ArgumentError
+        add_error(impossible_date_error(name, idx, val, line_number))
+      end
+
+      def check_uhrzeit(name, idx, val, line_number, _opts = nil)
+        return add_error(uhrzeit_format_error(name, idx, val, line_number)) unless
+          val.match?(/^\d{2}:\d{2}$/)
+
+        hh, mm = val.split(':').map(&:to_i)
+        return if (0..23).cover?(hh) && (0..59).cover?(mm)
+
+        add_error(time_out_of_range_error(name, idx, val, line_number))
+      end
+
+      def check_zeit(name, idx, val, line_number, _opts = nil)
+        return add_error(zeit_format_error(name, idx, val, line_number)) unless
+          val.match?(/^\d{2}:\d{2}:\d{2},\d{2}$/)
+
+        h, m, s, hh = parse_zeit_parts(val)
+        return if (0..23).cover?(h) && (0..59).cover?(m) && (0..59).cover?(s) && (0..99).cover?(hh)
+
+        add_error(time_out_of_range_error(name, idx, val, line_number))
+      end
+
+      def datum_format_error(name, idx, val, line_number)
+        "Element #{name}, attribute #{idx}: invalid Datum '#{val}' " \
+          "(expected TT.MM.JJJJ) (line #{line_number})"
+      end
+
+      def impossible_date_error(name, idx, val, line_number)
+        "Element #{name}, attribute #{idx}: impossible date '#{val}' (line #{line_number})"
+      end
+
+      def uhrzeit_format_error(name, idx, val, line_number)
+        "Element #{name}, attribute #{idx}: invalid Uhrzeit '#{val}' " \
+          "(expected HH:MM) (line #{line_number})"
+      end
+
+      def zeit_format_error(name, idx, val, line_number)
+        "Element #{name}, attribute #{idx}: invalid Zeit '#{val}' " \
+          "(expected HH:MM:SS,hh) (line #{line_number})"
+      end
+
+      def time_out_of_range_error(name, idx, val, line_number)
+        "Element #{name}, attribute #{idx}: time out of range '#{val}' (line #{line_number})"
+      end
+
+      def parse_zeit_parts(val)
+        h, m, s_hh = val.split(':')
+        s, hh = s_hh.split(',')
+        [h.to_i, m.to_i, s.to_i, hh.to_i]
+      end
+    end
+  end
+end

data/lib/dsv7/validator/types/enums1.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Dsv7
+  class Validator
+    module WkTypeChecksEnums1
+      def check_bahnl(name, idx, val, line_number, _opts = nil)
+        allowed = %w[16 20 25 33 50 FW X]
+        return if allowed.include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Bahnlänge '#{val}' (allowed: " \
+          "#{allowed.join(', ')}) (line #{line_number})"
+        )
+      end
+
+      def check_zeitmessung(name, idx, val, line_number, _opts = nil)
+        allowed = %w[HANDZEIT AUTOMATISCH HALBAUTOMATISCH]
+        return if allowed.include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Zeitmessung '#{val}' (allowed: " \
+          "#{allowed.join(', ')}) (line #{line_number})"
+        )
+      end
+
+      def check_land(name, idx, val, line_number, _opts = nil)
+        return if val.match?(/^[A-Z]{3}$/)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Land '#{val}' " \
+          "(expected FINA code, e.g., GER) (line #{line_number})"
+        )
+      end
+
+      def check_nachweis_bahn(name, idx, val, line_number, _opts = nil)
+        allowed = %w[25 50 FW AL]
+        return if allowed.include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Bahnlänge '#{val}' (allowed: " \
+          "#{allowed.join(', ')}) (line #{line_number})"
+        )
+      end
+
+      def check_relativ(name, idx, val, line_number, _opts = nil)
+        return if %w[J N].include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Relative Angabe '#{val}' (allowed: J, N) " \
+          "(line #{line_number})"
+        )
+      end
+
+      def check_wk_art(name, idx, val, line_number, _opts = nil)
+        return if %w[V Z F E].include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Wettkampfart '#{val}' " \
+          "(allowed: V, Z, F, E) (line #{line_number})"
+        )
+      end
+
+      # Wettkampfergebnisliste allows additional values 'A' and 'N'
+      def check_wk_art_erg(name, idx, val, line_number, _opts = nil)
+        return if %w[V Z F E A N].include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Wettkampfart '#{val}' " \
+          "(allowed: V, Z, F, E, A, N) (line #{line_number})"
+        )
+      end
+    end
+  end
+end

data/lib/dsv7/validator/types/enums2.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Dsv7
+  class Validator
+    module WkTypeChecksEnums2
+      def check_technik(name, idx, val, line_number, _opts = nil)
+        return if %w[F R B S L X].include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Technik '#{val}' " \
+          "(allowed: F, R, B, S, L, X) (line #{line_number})"
+        )
+      end
+
+      def check_ausuebung(name, idx, val, line_no, _opts = nil)
+        return if %w[GL BE AR ST WE GB X].include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Ausübung '#{val}' " \
+          "(allowed: GL, BE, AR, ST, WE, GB, X) (line #{line_no})"
+        )
+      end
+
+      def check_geschlecht_wk(name, idx, val, line_no, _opts = nil)
+        return if %w[M W X].include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Geschlecht '#{val}' (allowed: M, W, X) " \
+          "(line #{line_no})"
+        )
+      end
+
+      def check_bestenliste(name, idx, val, line_no, _opts = nil)
+        return if %w[SW EW PA MS KG XX].include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Zuordnung '#{val}' " \
+          "(allowed: SW, EW, PA, MS, KG, XX) (line #{line_no})"
+        )
+      end
+
+      def check_wert_typ(name, idx, val, line_number, _opts = nil)
+        return if %w[JG AK].include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Wertungstyp '#{val}' (allowed: JG, AK) " \
+          "(line #{line_number})"
+        )
+      end
+
+      def check_jgak(name, idx, val, line_number, _opts = nil)
+        return if val.match?(/^\d{1,4}$/) || val.match?(/^[ABCDEJ]$/) || val.match?(/^\d{2,3}\+$/)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid JG/AK '#{val}' (line #{line_number})"
+        )
+      end
+
+      def check_geschlecht_erw(name, idx, val, line_number, _opts = nil)
+        return if %w[M W X D].include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Geschlecht '#{val}' (allowed: M, W, X, D) " \
+          "(line #{line_number})"
+        )
+      end
+
+      def check_geschlecht_pf(name, idx, val, line_number, _opts = nil)
+        return if %w[M W D].include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Geschlecht '#{val}' (allowed: M, W, D) " \
+          "(line #{line_number})"
+        )
+      end
+
+      def check_meldegeld_typ(name, idx, val, line_number, _opts = nil)
+        allowed = %w[
+          MELDEGELDPAUSCHALE EINZELMELDEGELD STAFFELMELDEGELD WKMELDEGELD MANNSCHAFTMELDEGELD
+        ]
+        return if allowed.include?(val.upcase)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Meldegeld Typ '#{val}' (line #{line_number})"
+        )
+      end
+
+      def check_reaktion_art(name, idx, val, line_number, _opts = nil)
+        return if %w[+ -].include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Reaktionsart '#{val}' (allowed: +, -) " \
+          "(line #{line_number})"
+        )
+      end
+
+      def check_nachtrag_flag(name, idx, val, line_number, _opts = nil)
+        return if %w[E F N].include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Nachtragskennzeichen '#{val}' " \
+          "(allowed: E, F, N) (line #{line_number})"
+        )
+      end
+
+      def check_nichtwertung_grund(name, idx, val, line_number, _opts = nil)
+        allowed = %w[DS NA AB AU ZU]
+        return if allowed.include?(val)
+
+        add_error(
+          "Element #{name}, attribute #{idx}: invalid Grund der Nichtwertung '#{val}' " \
+          "(allowed: #{allowed.join(', ')}) (line #{line_number})"
+        )
+      end
+    end
+  end
+end

data/lib/dsv7/validator/types.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'types/common'
+require_relative 'types/datetime'
+require_relative 'types/enums1'
+require_relative 'types/enums2'
+
+module Dsv7
+  class Validator
+    module WkTypeChecks
+      include WkTypeChecksCommon
+      include WkTypeChecksDateTime
+      include WkTypeChecksEnums1
+      include WkTypeChecksEnums2
+    end
+  end
+end

data/lib/dsv7/validator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require_relative 'validator/result'
+require_relative 'validator/core'
+
+module Dsv7
+  # Validates overall conformity of a DSV7 file against high-level rules
+  # extracted from the specification markdown under `specification/dsv7`.
+  #
+  # Scope: structural and format-level checks that do not require
+  # knowledge of the full element schemas.
+  class Validator
+    # Known list types from the overview section
+    ALLOWED_LIST_TYPES = %w[
+      Wettkampfdefinitionsliste
+      Vereinsmeldeliste
+      Wettkampfergebnisliste
+      Vereinsergebnisliste
+    ].freeze
+
+    # Single public entrypoint. Accepts:
+    # - IO-like objects (respond_to?(:read)) → streamed
+    # - String paths to files → streamed
+    # - String content → streamed via StringIO
+    def self.validate(input)
+      return new.send(:validate_stream, input) if input.respond_to?(:read)
+      return validate_path(input) if input.is_a?(String) && File.file?(input)
+      return new.send(:validate_stream, StringIO.new(input.b)) if input.is_a?(String)
+
+      raise ArgumentError, 'Unsupported input; pass IO, file path String, or content String'
+    end
+
+    class << self
+      private
+
+      def validate_path(path)
+        File.open(path, 'rb') do |io|
+          return new.send(:validate_stream, io, filename: File.basename(path))
+        end
+      end
+    end
+
+    private
+
+    def validate_stream(io, filename: nil)
+      result = Result.new
+      Core.new(result, filename).call_io(io)
+    end
+  end
+end