ibex 0.1.0 → 0.2.0

data/sig/ibex/generation_transaction_recovery.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/ibex/generation_transaction_recovery.rb with RBS::Inline
+
+module Ibex
+  # Failure recovery and best-effort cleanup for GenerationTransaction.
+  module GenerationTransactionRecovery
+    private
+
+    # @rbs (Exception cause) -> bot
+    def handle_failure: (Exception cause) -> bot
+
+    # @rbs (Exception cause, Array[String] rollback, Array[String] cleanup, Array[String] sync) -> bool
+    def source_change_clean?: (Exception cause, Array[String] rollback, Array[String] cleanup, Array[String] sync) -> bool
+
+    # rubocop:disable Layout/LineLength
+    # @rbs (Exception cause, Array[String] rollback, Array[String] cleanup, Array[String] sync, Array[String] recovery) -> Array[String]
+    def failure_details: (Exception cause, Array[String] rollback, Array[String] cleanup, Array[String] sync, Array[String] recovery) -> Array[String]
+
+    # @rbs () -> Array[String]
+    def recovery_artifacts: () -> Array[String]
+
+    # @rbs () -> Array[String]
+    def rollback: () -> Array[String]
+
+    # @rbs (Hash[Symbol, untyped] record) -> void
+    def rollback_record: (Hash[Symbol, untyped] record) -> void
+
+    # @rbs (preserve_backups: bool) -> Array[String]
+    def cleanup_artifacts: (preserve_backups: bool) -> Array[String]
+
+    # @rbs (String path, Array[String] failures) -> void
+    def remove_artifact: (String path, Array[String] failures) -> void
+
+    # @rbs () -> Array[String]
+    def sync_directories_best_effort: () -> Array[String]
+  end
+end

data/sig/ibex/generation_transaction_validation.rbs

@@ -0,0 +1,65 @@
+# Generated from lib/ibex/generation_transaction_validation.rb with RBS::Inline
+
+module Ibex
+  # Canonical target, source, symlink, and lock identity checks for generation.
+  module GenerationTransactionValidation
+    private def lock_path: (String) -> String
+
+    private
+
+    # Follow a final symlink while preserving the symlink path itself during publication.
+    # @rbs (String path, ?Hash[String, bool] seen, ?validate_links: bool) -> String
+    def resolved_target: (String path, ?Hash[String, bool] seen, ?validate_links: bool) -> String
+
+    # @rbs (String expanded, bool validate_links) -> String
+    def existing_target: (String expanded, bool validate_links) -> String
+
+    # @rbs (String target) -> void
+    def validate_existing_target!: (String target) -> void
+
+    # @rbs () -> void
+    def validate_source_boundaries!: () -> void
+
+    # @rbs (Array[String] lock_paths) -> void
+    def validate_lock_boundaries!: (Array[String] lock_paths) -> void
+
+    # @rbs (String path, File lock) -> void
+    def validate_lock_identity!: (String path, File lock) -> void
+
+    # @rbs () -> Array[String]
+    def protected_generation_paths: () -> Array[String]
+
+    # @rbs () -> Array[File::Stat]
+    def protected_generation_stats: () -> Array[File::Stat]
+
+    # @rbs (File::Stat path_stat, File::Stat lock_stat) -> bool
+    def stable_lock_identity?: (File::Stat path_stat, File::Stat lock_stat) -> bool
+
+    # @rbs (File::Stat left, File::Stat right) -> bool
+    def same_inode?: (File::Stat left, File::Stat right) -> bool
+
+    # @rbs (String left, String right) -> bool
+    def paths_alias?: (String left, String right) -> bool
+
+    # Reject target names that collide on common case-insensitive or
+    # normalization-insensitive filesystems, even when the current filesystem
+    # would permit both names.
+    # @rbs (String path) -> [String, String]
+    def portable_target_key: (String path) -> [ String, String ]
+
+    # @rbs (String phase) -> void
+    def ensure_sources_stable!: (String phase) -> void
+
+    # @rbs (String phase) -> void
+    def validate_active_locks!: (String phase) -> void
+
+    # @rbs (String phase) -> void
+    def validate_current_targets!: (String phase) -> void
+
+    # @rbs (Hash[Symbol, untyped] record, Array[String] sources, String phase) -> void
+    def validate_current_target!: (Hash[Symbol, untyped] record, Array[String] sources, String phase) -> void
+
+    # @rbs () -> void
+    def validate_locked_targets!: () -> void
+  end
+end

data/sig/ibex/grammar_tests.rbs

@@ -0,0 +1,93 @@
+# Generated from lib/ibex/grammar_tests.rb with RBS::Inline
+
+module Ibex
+  # Executes grammar-declared source examples against one generated parser.
+  module GrammarTests
+    DEFAULT_TIMEOUT: ::Integer
+
+    RESULT_MARKER: ::String
+
+    class Result < Struct[Symbol | String? | IR::location | Array[Integer]]
+      attr_accessor expectation(): Symbol
+
+      attr_accessor actual(): Symbol
+
+      attr_accessor error_class(): String?
+
+      attr_accessor error_message(): String?
+
+      attr_accessor location(): IR::location
+
+      attr_accessor production_ids(): Array[Integer]
+
+      def self.new: (?expectation: Symbol, ?actual: Symbol, ?error_class: String?, ?error_message: String?, ?location: IR::location, ?production_ids: Array[Integer]) -> instance
+                  | ({ ?expectation: Symbol, ?actual: Symbol, ?error_class: String?, ?error_message: String?, ?location: IR::location, ?production_ids: Array[Integer] }) -> instance
+    end
+
+    class Result
+      # @rbs () -> bool
+      def passed?: () -> bool
+    end
+
+    class ProductionCoverage < Struct[Array[Integer] | Integer]
+      attr_accessor covered_ids(): Array[Integer]
+
+      attr_accessor missing_ids(): Array[Integer]
+
+      attr_accessor production_count(): Integer
+
+      def self.new: (?covered_ids: Array[Integer], ?missing_ids: Array[Integer], ?production_count: Integer) -> instance
+                  | ({ ?covered_ids: Array[Integer], ?missing_ids: Array[Integer], ?production_count: Integer }) -> instance
+    end
+
+    class ProductionCoverage
+      # @rbs () -> Float
+      def percentage: () -> Float
+
+      # @rbs (Integer minimum) -> bool
+      def meets?: (Integer minimum) -> bool
+
+      # @rbs () -> bool
+      def complete?: () -> bool
+    end
+
+    # Runs all examples in one isolated process while creating a fresh parser
+    # instance for every case.
+    class Runner
+      CHILD_RUNNER: ::String
+
+      @automaton: IR::Automaton
+
+      @timeout: Integer
+
+      # @rbs (IR::Automaton automaton, ?timeout: Integer) -> void
+      def initialize: (IR::Automaton automaton, ?timeout: Integer) -> void
+
+      # @rbs () -> Array[Result]
+      def run: () -> Array[Result]
+
+      # @rbs (Array[Result] results) -> ProductionCoverage
+      def production_coverage: (Array[Result] results) -> ProductionCoverage
+
+      private
+
+      # @rbs () -> String
+      def generated_parser: () -> String
+
+      # @rbs (String parser_path, String runner_path) -> Array[Result]
+      def execute_child: (String parser_path, String runner_path) -> Array[Result]
+
+      # @rbs (Integer pid) -> Process::Status
+      def wait_for_child: (Integer pid) -> Process::Status
+
+      # @rbs (Process::Status status, String errors) -> bot
+      def raise_child_failure: (Process::Status status, String errors) -> bot
+
+      # @rbs (String output) -> Array[Result]
+      def decode_results: (String output) -> Array[Result]
+
+      # @rbs (IR::grammar_test test, untyped document) -> Result
+      def build_result: (IR::grammar_test test, untyped document) -> Result
+    end
+  end
+end

data/sig/ibex/ir/automaton_ir.rbs

@@ -57,19 +57,25 @@ module Ibex
 
       attr_reader states: Array[AutomatonState]
 
+      attr_reader entry_states: Hash[String, Integer]
+
       attr_reader conflict_summary: conflict_summary
 
       attr_reader schema_version: Integer
 
       # @rbs (grammar: Grammar, states: Array[AutomatonState], conflict_summary: conflict_summary,
-      #   ?algorithm: String, ?grammar_digest: String?, ?schema_version: Integer) -> void
-      def initialize: (grammar: Grammar, states: Array[AutomatonState], conflict_summary: conflict_summary, ?algorithm: String, ?grammar_digest: String?, ?schema_version: Integer) -> void
+      #   ?algorithm: String, ?grammar_digest: String?, ?schema_version: Integer,
+      #   ?entry_states: Hash[String, Integer]?) -> void
+      def initialize: (grammar: Grammar, states: Array[AutomatonState], conflict_summary: conflict_summary, ?algorithm: String, ?grammar_digest: String?, ?schema_version: Integer, ?entry_states: Hash[String, Integer]?) -> void
 
       # @rbs () -> Hash[Symbol, untyped]
       def to_h: () -> Hash[Symbol, untyped]
 
       private
 
+      # @rbs () -> void
+      def validate_entry_states: () -> void
+
       # @rbs (Grammar grammar) -> String
       def digest_for: (Grammar grammar) -> String
     end

data/sig/ibex/ir/grammar_ir.rbs

@@ -4,6 +4,8 @@ module Ibex
   module IR
     SCHEMA_VERSION: ::Integer
 
+    SUPPORTED_SCHEMA_VERSIONS: Array[Integer]
+
     # @rbs (untyped value) -> untyped
     def self?.deep_freeze: (untyped value) -> untyped
 
@@ -21,9 +23,15 @@ module Ibex
 
       attr_reader location: location?
 
+      attr_reader display_name: String?
+
+      attr_reader semantic_type: String?
+
+      attr_reader documentation: String?
+
       # @rbs (id: Integer, name: String, kind: Symbol, ?reserved: bool, ?precedence: precedence?,
-      #   ?location: location?) -> void
-      def initialize: (id: Integer, name: String, kind: Symbol, ?reserved: bool, ?precedence: precedence?, ?location: location?) -> void
+      #   ?location: location?, ?display_name: String?, ?semantic_type: String?, ?documentation: String?) -> void
+      def initialize: (id: Integer, name: String, kind: Symbol, ?reserved: bool, ?precedence: precedence?, ?location: location?, ?display_name: String?, ?semantic_type: String?, ?documentation: String?) -> void
 
       # @rbs () -> bool
       def terminal?: () -> bool
@@ -31,8 +39,8 @@ module Ibex
       # @rbs () -> bool
       def nonterminal?: () -> bool
 
-      # @rbs () -> Hash[Symbol, untyped]
-      def to_h: () -> Hash[Symbol, untyped]
+      # @rbs (?schema_version: Integer) -> Hash[Symbol, untyped]
+      def to_h: (?schema_version: Integer) -> Hash[Symbol, untyped]
     end
 
     # Opaque Ruby semantic action metadata.
@@ -45,11 +53,14 @@ module Ibex
 
       attr_reader context_length: Integer
 
-      # @rbs (code: String, location: location, ?named_refs: Array[named_ref], ?context_length: Integer) -> void
-      def initialize: (code: String, location: location, ?named_refs: Array[named_ref], ?context_length: Integer) -> void
+      attr_reader composition: action_composition?
 
-      # @rbs () -> Hash[Symbol, untyped]
-      def to_h: () -> Hash[Symbol, untyped]
+      # @rbs (code: String, location: location, ?named_refs: Array[named_ref], ?context_length: Integer,
+      #   ?composition: action_composition?) -> void
+      def initialize: (code: String, location: location, ?named_refs: Array[named_ref], ?context_length: Integer, ?composition: action_composition?) -> void
+
+      # @rbs (?schema_version: Integer) -> Hash[Symbol, untyped]
+      def to_h: (?schema_version: Integer) -> Hash[Symbol, untyped]
     end
 
     # A normalized BNF production using symbol ids.
@@ -66,12 +77,19 @@ module Ibex
 
       attr_reader origin: Hash[Symbol, untyped]
 
+      attr_reader documentation: String?
+
+      attr_reader expansion: production_expansion?
+
+      attr_reader node: node_annotation?
+
       # @rbs (id: Integer, lhs: Integer, rhs: Array[Integer], action: Action?, precedence_override: Integer?,
-      #   origin: Hash[Symbol, untyped]) -> void
-      def initialize: (id: Integer, lhs: Integer, rhs: Array[Integer], action: Action?, precedence_override: Integer?, origin: Hash[Symbol, untyped]) -> void
+      #   origin: Hash[Symbol, untyped], ?documentation: String?, ?expansion: production_expansion?,
+      #   ?node: node_annotation?) -> void
+      def initialize: (id: Integer, lhs: Integer, rhs: Array[Integer], action: Action?, precedence_override: Integer?, origin: Hash[Symbol, untyped], ?documentation: String?, ?expansion: production_expansion?, ?node: node_annotation?) -> void
 
-      # @rbs () -> Hash[Symbol, untyped]
-      def to_h: () -> Hash[Symbol, untyped]
+      # @rbs (?schema_version: Integer) -> Hash[Symbol, untyped]
+      def to_h: (?schema_version: Integer) -> Hash[Symbol, untyped]
     end
 
     # One opaque user-code block and the location of its first code line.
@@ -95,8 +113,24 @@ module Ibex
 
       attr_reader start: String
 
+      attr_reader starts: Array[String]
+
+      attr_reader mode: grammar_mode
+
       attr_reader expect: Integer
 
+      attr_reader expect_rr: Integer?
+
+      attr_reader parser_parameters: Array[parser_parameter]
+
+      attr_reader value_printers: Array[value_printer]
+
+      attr_reader grammar_tests: Array[grammar_test]
+
+      attr_reader lexer: Lexer?
+
+      attr_reader recovery: recovery_policy
+
       attr_reader options: grammar_options
 
       attr_reader symbols: Array[GrammarSymbol]
@@ -113,11 +147,22 @@ module Ibex
 
       attr_reader schema_version: Integer
 
-      # @rbs (class_name: String, superclass: String?, start: String, expect: Integer, options: grammar_options,
+      attr_reader source_provenance: source_provenance?
+
+      attr_reader migration: migration_metadata?
+
+      # @rbs (class_name: String, superclass: String?, start: String, expect: Integer, ?expect_rr: Integer?,
+      #   options: grammar_options,
       #   symbols: Array[GrammarSymbol], productions: Array[Production], user_code: Hash[String, String],
       #   conversions: Hash[String, String], warnings: Array[grammar_warning], ?user_code_chunks: user_code_chunks?,
-      #   ?schema_version: Integer) -> void
-      def initialize: (class_name: String, superclass: String?, start: String, expect: Integer, options: grammar_options, symbols: Array[GrammarSymbol], productions: Array[Production], user_code: Hash[String, String], conversions: Hash[String, String], warnings: Array[grammar_warning], ?user_code_chunks: user_code_chunks?, ?schema_version: Integer) -> void
+      #   ?schema_version: Integer, ?source_provenance: source_provenance?,
+      #   ?migration: migration_metadata?, ?parser_parameters: Array[parser_parameter],
+      #   ?value_printers: Array[value_printer], ?grammar_tests: Array[grammar_test],
+      #   ?recovery: recovery_policy?, ?lexer: Lexer?,
+      #   ?mode: grammar_mode, ?starts: Array[String]?) -> void
+      # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists
+      # Immutable versioned IR is constructed from explicit public fields.
+      def initialize: (class_name: String, superclass: String?, start: String, expect: Integer, options: grammar_options, symbols: Array[GrammarSymbol], productions: Array[Production], user_code: Hash[String, String], conversions: Hash[String, String], warnings: Array[grammar_warning], ?expect_rr: Integer?, ?user_code_chunks: user_code_chunks?, ?schema_version: Integer, ?source_provenance: source_provenance?, ?migration: migration_metadata?, ?parser_parameters: Array[parser_parameter], ?value_printers: Array[value_printer], ?grammar_tests: Array[grammar_test], ?recovery: recovery_policy?, ?lexer: Lexer?, ?mode: grammar_mode, ?starts: Array[String]?) -> void
 
       # @rbs (String name) -> GrammarSymbol?
       def symbol: (String name) -> GrammarSymbol?
@@ -136,6 +181,21 @@ module Ibex
 
       private
 
+      # @rbs (grammar_mode mode) -> void
+      def validate_mode: (grammar_mode mode) -> void
+
+      # @rbs (String start, Array[String]? starts, grammar_mode mode) -> Array[String]
+      def validate_starts: (String start, Array[String]? starts, grammar_mode mode) -> Array[String]
+
+      # @rbs (Hash[Symbol, untyped] value) -> void
+      def append_optional_metadata: (Hash[Symbol, untyped] value) -> void
+
+      # @rbs (Hash[Symbol, untyped] value) -> void
+      def append_parser_metadata: (Hash[Symbol, untyped] value) -> void
+
+      # @rbs (Hash[Symbol, untyped] value) -> void
+      def append_recovery_metadata: (Hash[Symbol, untyped] value) -> void
+
       # @rbs () -> void
       def validate_user_code_chunks: () -> void
     end

data/sig/ibex/ir/lexer_ir.rbs

@@ -0,0 +1,57 @@
+# Generated from lib/ibex/ir/lexer_ir.rb with RBS::Inline
+
+module Ibex
+  module IR
+    LEXER_SCHEMA_VERSION: ::Integer
+
+    SUPPORTED_LEXER_SCHEMA_VERSIONS: Array[Integer]
+
+    # One normalized, state-scoped lexer rule.
+    class LexerRule
+      attr_reader id: Integer
+
+      attr_reader state: String
+
+      attr_reader kind: Symbol
+
+      attr_reader token: String?
+
+      attr_reader pattern: String
+
+      attr_reader pattern_kind: Symbol
+
+      attr_reader options: String
+
+      attr_reader action: String?
+
+      attr_reader location: location
+
+      # @rbs (id: Integer, state: String, kind: Symbol, token: String?, pattern: String, pattern_kind: Symbol,
+      #   options: String, action: String?, location: location) -> void
+      def initialize: (id: Integer, state: String, kind: Symbol, token: String?, pattern: String, pattern_kind: Symbol, options: String, action: String?, location: location) -> void
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
+    # Independently versioned lexer contract embedded by Grammar IR v2.
+    class Lexer
+      attr_reader states: Array[String]
+
+      attr_reader rules: Array[LexerRule]
+
+      attr_reader warnings: Array[Hash[Symbol, untyped]]
+
+      attr_reader schema_version: Integer
+
+      attr_reader source_provenance: source_provenance?
+
+      # @rbs (states: Array[String], rules: Array[LexerRule], warnings: Array[Hash[Symbol, untyped]],
+      #   ?schema_version: Integer, ?source_provenance: source_provenance?) -> void
+      def initialize: (states: Array[String], rules: Array[LexerRule], warnings: Array[Hash[Symbol, untyped]], ?schema_version: Integer, ?source_provenance: source_provenance?) -> void
+
+      # @rbs () -> Hash[Symbol, untyped]
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+  end
+end

data/sig/ibex/ir/migration.rbs

@@ -0,0 +1,34 @@
+# Generated from lib/ibex/ir/migration.rb with RBS::Inline
+
+module Ibex
+  module IR
+    # Meaning-preserving upgrades between published IR schema versions.
+    module Migration
+      UNAVAILABLE_V1_METADATA: Array[String]
+
+      # @rbs (Grammar | Automaton value, ?to: Integer) -> (Grammar | Automaton)
+      def self?.to_version: (Grammar | Automaton value, ?to: Integer) -> (Grammar | Automaton)
+
+      # @rbs (Grammar | Automaton value) -> (Grammar | Automaton)
+      def self?.to_v2: (Grammar | Automaton value) -> (Grammar | Automaton)
+
+      # @rbs (Grammar grammar) -> Grammar
+      def self?.migrate_grammar: (Grammar grammar) -> Grammar
+
+      # @rbs (Grammar grammar) -> Array[GrammarSymbol]
+      def self?.migrate_symbols: (Grammar grammar) -> Array[GrammarSymbol]
+
+      # @rbs (Grammar grammar) -> Array[Production]
+      def self?.migrate_productions: (Grammar grammar) -> Array[Production]
+
+      # @rbs (Grammar grammar, Array[GrammarSymbol] symbols, Array[Production] productions) -> Grammar
+      def self?.build_migrated_grammar: (Grammar grammar, Array[GrammarSymbol] symbols, Array[Production] productions) -> Grammar
+
+      # @rbs (Action? action) -> Action?
+      def self?.migrate_action: (Action? action) -> Action?
+
+      # @rbs (Automaton automaton) -> Automaton
+      def self?.migrate_automaton: (Automaton automaton) -> Automaton
+    end
+  end
+end

data/sig/ibex/ir/serialize.rbs

@@ -3,6 +3,7 @@
 module Ibex
   module IR
     # Stable JSON serialization for versioned pipeline IR.
+    # rubocop:disable Metrics/ModuleLength -- explicit versioned fields keep serialization changes auditable.
     module Serialize
       private def validate_version: (untyped data) -> untyped
 
@@ -16,6 +17,10 @@ module Ibex
 
       private def self.load_automaton: (untyped data) -> untyped
 
+      private def load_lexer: (untyped data) -> untyped
+
+      private def self.load_lexer: (untyped data) -> untyped
+
       private def load_state: (untyped state, untyped grammar) -> untyped
 
       private def self.load_state: (untyped state, untyped grammar) -> untyped
@@ -28,23 +33,35 @@ module Ibex
 
       private def self.normalize_action: (untyped value) -> untyped
 
-      private def load_production: (untyped production) -> untyped
+      private def load_production: (untyped production, Integer schema_version) -> untyped
 
-      private def self.load_production: (untyped production) -> untyped
+      private def self.load_production: (untyped production, Integer schema_version) -> untyped
 
       private def load_user_code_chunks: (untyped chunks) -> untyped
 
       private def self.load_user_code_chunks: (untyped chunks) -> untyped
 
+      private def load_symbol_metadata: (untyped symbol, String field) -> String?
+
+      private def self.load_symbol_metadata: (untyped symbol, String field) -> String?
+
+      private def load_grammar_tests: (untyped tests) -> untyped
+
+      private def self.load_grammar_tests: (untyped tests) -> untyped
+
+      private def symbol_source_position: (untyped symbol) -> String
+
+      private def self.symbol_source_position: (untyped symbol) -> String
+
       private def symbolize: (untyped value) -> untyped
 
       private def self.symbolize: (untyped value) -> untyped
 
-      # @rbs (Grammar | Automaton value) -> String
-      def self?.dump: (Grammar | Automaton value) -> String
+      # @rbs (Grammar | Automaton | Lexer value) -> String
+      def self?.dump: (Grammar | Automaton | Lexer value) -> String
 
-      # @rbs (String source) -> (Grammar | Automaton)
-      def self?.load: (String source) -> (Grammar | Automaton)
+      # @rbs (String source) -> (Grammar | Automaton | Lexer)
+      def self?.load: (String source) -> (Grammar | Automaton | Lexer)
     end
   end
 end

data/sig/ibex/ir/validator/automaton.rbs

@@ -0,0 +1,109 @@
+# Generated from lib/ibex/ir/validator/automaton.rb with RBS::Inline
+
+module Ibex
+  module IR
+    module Validator
+      # Structural and referential validation for a versioned Automaton IR JSON object.
+      # rubocop:disable Metrics/ClassLength -- inline type contracts accompany one cohesive document validator.
+      class AutomatonDocument < Base
+        ROOT_REQUIRED: Array[String]
+
+        V2_ROOT_OPTIONAL: Array[String]
+
+        STATE_REQUIRED: Array[String]
+
+        ACTION_TYPES: Array[String]
+
+        RESOLUTION_KINDS: Array[String]
+
+        @version: Integer
+
+        @grammar: GrammarDocument
+
+        @states_by_id: Hash[Integer, Hash[String, untyped]]
+
+        @data: Hash[String, untyped]
+
+        # @rbs (Hash[String, untyped] data, ?version: Integer) -> void
+        def initialize: (Hash[String, untyped] data, ?version: Integer) -> void
+
+        # @rbs () -> self
+        def validate: () -> self
+
+        private
+
+        # @rbs () -> void
+        def validate_entry_states: () -> void
+
+        # @rbs () -> void
+        def validate_digest: () -> void
+
+        # @rbs () -> void
+        def validate_state_records: () -> void
+
+        # @rbs () -> void
+        def validate_state_contents: () -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_items: (untyped value, String path) -> void
+
+        # @rbs (Integer production_id, untyped dot_value, String path) -> void
+        def validate_item_production: (Integer production_id, untyped dot_value, String path) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_lookaheads: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_transitions: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_actions: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_gotos: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path, ?kind: String?) { (untyped, String, Hash[String, untyped]) -> void } -> void
+        def symbol_map: (untyped value, String path, ?kind: String?) { (untyped, String, Hash[String, untyped]) -> void } -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_state_reference: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path, ?nullable: bool) -> void
+        def validate_parser_action: (untyped value, String path, ?nullable: bool) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_production_reference: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_conflicts: (untyped value, String path) -> void
+
+        # @rbs (Hash[String, untyped] conflict, String path) -> void
+        def validate_shift_reduce: (Hash[String, untyped] conflict, String path) -> void
+
+        # @rbs (Hash[String, untyped] conflict, String path) -> void
+        def validate_reduce_reduce: (Hash[String, untyped] conflict, String path) -> void
+
+        # @rbs (Hash[String, untyped] conflict, String path) -> void
+        def validate_conflict_entries: (Hash[String, untyped] conflict, String path) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_midrule_origins: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_conflict_symbol: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path, ?reductions: Array[Integer]?) -> void
+        def validate_resolution: (untyped value, String path, ?reductions: Array[Integer]?) -> void
+
+        # @rbs () -> void
+        def validate_conflict_summary: () -> void
+
+        # @rbs (Hash[String, untyped] summary, String path) -> void
+        def validate_conflict_counts: (Hash[String, untyped] summary, String path) -> void
+
+        # @rbs (Hash[String, untyped] summary, String path) -> void
+        def validate_expectation: (Hash[String, untyped] summary, String path) -> void
+      end
+    end
+  end
+end