ibex 0.1.0 → 0.2.0

data/sig/ibex/lalr/direct_lookaheads.rbs

@@ -0,0 +1,86 @@
+# Generated from lib/ibex/lalr/direct_lookaheads.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Builds an LR(0) collection and propagates LALR(1) lookaheads directly
+    # over item occurrences. Canonical LR(1) states are never materialized.
+    class DirectLookaheads
+      AUGMENTED_PRODUCTION: Integer
+
+      EMPTY_PRODUCTIONS: Array[IR::Production]
+
+      EMPTY_NODES: Array[lookahead_node]
+
+      @terminal_masks: Array[Integer]
+
+      @terminal_ids: Array[Integer]
+
+      @production_item_cores: Array[Array[item_core]]
+
+      @augmented_item_cores: Array[item_core]
+
+      @production_rhs: Array[Array[Integer]]
+
+      @augmented_rhs: Array[Integer]
+
+      @productions_by_lhs: Hash[Integer, Array[IR::Production]]
+
+      @sets: Analysis::Sets
+
+      @grammar: IR::Grammar
+
+      # @rbs (IR::Grammar grammar, Analysis::Sets sets) -> void
+      def initialize: (IR::Grammar grammar, Analysis::Sets sets) -> void
+
+      # @rbs () -> [Array[packed_items], transitions]
+      def build: () -> [ Array[packed_items], transitions ]
+
+      private
+
+      # @rbs () -> [Array[core_set], transitions]
+      def lr0_collection: () -> [ Array[core_set], transitions ]
+
+      # @rbs (core_set seed) -> core_set
+      def closure: (core_set seed) -> core_set
+
+      # @rbs (core_set items) -> Hash[Integer, core_set]
+      def shifted_kernels: (core_set items) -> Hash[Integer, core_set]
+
+      # @rbs (Array[core_set] states) -> Array[packed_items]
+      def empty_lookaheads: (Array[core_set] states) -> Array[packed_items]
+
+      # @rbs (Array[core_set] states, transitions transitions, Array[packed_items] lookaheads) ->
+      #   Hash[lookahead_node, Array[lookahead_node]]
+      def propagation_graph: (Array[core_set] states, transitions transitions, Array[packed_items] lookaheads) -> Hash[lookahead_node, Array[lookahead_node]]
+
+      # @rbs (Hash[lookahead_node, Array[lookahead_node]] edges, transitions transitions,
+      #   Integer state_id, Integer production_id, Integer dot) -> void
+      def add_transition_edge: (Hash[lookahead_node, Array[lookahead_node]] edges, transitions transitions, Integer state_id, Integer production_id, Integer dot) -> void
+
+      # @rbs (Hash[lookahead_node, Array[lookahead_node]] edges, Array[packed_items] lookaheads,
+      #   Integer state_id, Integer production_id, Integer dot) -> void
+      def add_closure_relations: (Hash[lookahead_node, Array[lookahead_node]] edges, Array[packed_items] lookaheads, Integer state_id, Integer production_id, Integer dot) -> void
+
+      # @rbs (Array[packed_items] lookaheads, Hash[lookahead_node, Array[lookahead_node]] edges) -> void
+      def propagate: (Array[packed_items] lookaheads, Hash[lookahead_node, Array[lookahead_node]] edges) -> void
+
+      # @rbs (Array[packed_items] lookaheads, lookahead_node node) -> Set[Integer]
+      def node_set: (Array[packed_items] lookaheads, lookahead_node node) -> Set[Integer]
+
+      # @rbs (Integer bits) -> Array[Integer]
+      def terminal_ids: (Integer bits) -> Array[Integer]
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for: (Integer production_id) -> Array[Integer]
+
+      # @rbs (Integer production_id, Integer rhs_length) -> Array[item_core]
+      def item_cores_for: (Integer production_id, Integer rhs_length) -> Array[item_core]
+
+      # @rbs (Integer production_id, Integer dot) -> item_core
+      def item_core: (Integer production_id, Integer dot) -> item_core
+
+      # @rbs (core_set items) -> Array[item_core]
+      def item_key: (core_set items) -> Array[item_core]
+    end
+  end
+end

data/sig/ibex/lalr/ielr_partition.rbs

@@ -0,0 +1,59 @@
+# Generated from lib/ibex/lalr/ielr_partition.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Deterministically merges compatible canonical LR(1) states and splits
+    # partitions until their outgoing transitions are congruent.
+    class IELRPartition
+      AUGMENTED_PRODUCTION: Integer
+
+      @contributions: Array[Hash[Integer, Set[Array[untyped]]]]
+
+      @transitions: transitions
+
+      @states: Array[item_set]
+
+      @grammar: IR::Grammar
+
+      # @rbs (IR::Grammar grammar, Array[item_set] states, transitions transitions) -> void
+      def initialize: (IR::Grammar grammar, Array[item_set] states, transitions transitions) -> void
+
+      # @rbs () -> [Array[packed_items], transitions]
+      def build: () -> [ Array[packed_items], transitions ]
+
+      private
+
+      # @rbs () -> Array[state_partition]
+      def initial_partitions: () -> Array[state_partition]
+
+      # @rbs (Array[Integer] members) -> Array[state_partition]
+      def compatible_partitions: (Array[Integer] members) -> Array[state_partition]
+
+      # A canonical member may gain an action only where it previously had no
+      # action. Every nonempty member cell must equal the merged cell.
+      # @rbs (state_partition members) -> bool
+      def compatible?: (state_partition members) -> bool
+
+      # @rbs (Array[state_partition] partitions) -> Array[state_partition]
+      def refine_transitions: (Array[state_partition] partitions) -> Array[state_partition]
+
+      # @rbs (Integer state_id, Hash[Integer, Integer] indexes) -> Array[[Integer, Integer]]
+      def transition_signature: (Integer state_id, Hash[Integer, Integer] indexes) -> Array[[ Integer, Integer ]]
+
+      # @rbs (Array[state_partition] partitions) -> Hash[Integer, Integer]
+      def partition_indexes: (Array[state_partition] partitions) -> Hash[Integer, Integer]
+
+      # @rbs (state_partition members) -> packed_items
+      def merge_items: (state_partition members) -> packed_items
+
+      # @rbs (Integer state_id) -> Hash[Integer, Set[Array[untyped]]]
+      def action_contributions: (Integer state_id) -> Hash[Integer, Set[Array[untyped]]]
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for: (Integer production_id) -> Array[Integer]
+
+      # @rbs (item_set items) -> Array[item_core]
+      def core_key: (item_set items) -> Array[item_core]
+    end
+  end
+end

data/sig/ibex/lalr/on_error_reductions.rbs

@@ -0,0 +1,22 @@
+# Generated from lib/ibex/lalr/on_error_reductions.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Delays syntax-error detection by filling only otherwise erroneous table
+    # cells with one uniquely highest-priority declared reduction.
+    module OnErrorReductions
+      # @rbs (IR::Grammar grammar, Array[IR::AutomatonState] states) -> Array[IR::AutomatonState]
+      def self?.apply: (IR::Grammar grammar, Array[IR::AutomatonState] states) -> Array[IR::AutomatonState]
+
+      # @rbs (IR::Grammar grammar) -> Hash[Integer, Integer]
+      def self?.reduction_priorities: (IR::Grammar grammar) -> Hash[Integer, Integer]
+
+      # @rbs (IR::Grammar grammar, IR::AutomatonState state, Hash[Integer, Integer] priorities,
+      #   Array[Integer] terminal_ids) -> IR::AutomatonState
+      def apply_state: (IR::Grammar grammar, IR::AutomatonState state, Hash[Integer, Integer] priorities, Array[Integer] terminal_ids) -> IR::AutomatonState
+
+      # @rbs (IR::Grammar grammar, IR::AutomatonState state, Hash[Integer, Integer] priorities) -> Integer?
+      def selected_production: (IR::Grammar grammar, IR::AutomatonState state, Hash[Integer, Integer] priorities) -> Integer?
+    end
+  end
+end

data/sig/ibex/lalr.rbs

@@ -6,12 +6,18 @@ module Ibex
 
     type item_core = [ Integer, Integer ]
 
+    type core_set = Set[item_core]
+
     type item_set = Set[lr_item]
 
     type packed_items = Hash[item_core, Set[Integer]]
 
     type transitions = Array[Hash[Integer, Integer]]
 
+    type lookahead_node = [ Integer, Integer, Integer ]
+
+    type state_partition = Array[Integer]
+
     type derivation_node = Hash[Symbol, untyped]
 
     type search_status = :conflict | :shifted | :accepted

data/sig/ibex/location.rbs

@@ -0,0 +1,67 @@
+# Generated from lib/ibex/location.rb with RBS::Inline
+
+module Ibex
+  # Immutable source range suitable for lexer tokens and parser diagnostics.
+  #
+  # Coordinates are one-based. Byte offsets are optional, zero-based, and
+  # half-open. Keeping both forms lets Unicode-aware lexers report human
+  # columns without losing an exact source slice.
+  class Location
+    attr_reader file: String?
+
+    attr_reader line: Integer
+
+    attr_reader column: Integer
+
+    attr_reader end_line: Integer
+
+    attr_reader end_column: Integer
+
+    attr_reader start_byte: Integer?
+
+    attr_reader end_byte: Integer?
+
+    attr_reader source_line: String?
+
+    # @rbs (?file: String?, line: Integer, column: Integer, ?end_line: Integer?,
+    #   ?end_column: Integer?, ?start_byte: Integer?, ?end_byte: Integer?, ?source_line: String?) -> void
+    def initialize: (line: Integer, column: Integer, ?file: String?, ?end_line: Integer?, ?end_column: Integer?, ?start_byte: Integer?, ?end_byte: Integer?, ?source_line: String?) -> void
+
+    # Return the smallest range covering both locations.
+    # @rbs (Location other) -> Location
+    def join: (Location other) -> Location
+
+    # Fold a nonempty collection into one covering range.
+    # @rbs (Enumerable[Location] locations) -> Location
+    def self.join: (Enumerable[Location] locations) -> Location
+
+    # @rbs () -> bool
+    def empty?: () -> bool
+
+    # @rbs () -> Hash[Symbol, untyped]
+    def to_h: () -> Hash[Symbol, untyped]
+
+    private
+
+    # @rbs (Symbol name, untyped value) -> Integer
+    def positive_coordinate: (Symbol name, untyped value) -> Integer
+
+    # @rbs (Symbol name, untyped value) -> Integer?
+    def optional_offset: (Symbol name, untyped value) -> Integer?
+
+    # @rbs () -> void
+    def validate_order!: () -> void
+
+    # @rbs (Location left, Location right) -> bool
+    def before_or_equal?: (Location left, Location right) -> bool
+
+    # @rbs (Location left, Location right) -> bool
+    def before_or_equal_end?: (Location left, Location right) -> bool
+
+    # @rbs (Location other) -> Integer?
+    def joined_start_byte: (Location other) -> Integer?
+
+    # @rbs (Location other) -> Integer?
+    def joined_end_byte: (Location other) -> Integer?
+  end
+end

data/sig/ibex/lsp/document_handlers.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/ibex/lsp/document_handlers.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Applies full-text LSP document notifications to the overlay-backed store.
+    module DocumentHandlers
+      include RequestSupport
+
+      private
+
+      # @rbs (untyped raw_params) -> nil
+      def did_open: (untyped raw_params) -> nil
+
+      # @rbs (untyped raw_params) -> nil
+      def did_change: (untyped raw_params) -> nil
+
+      # @rbs (untyped raw_params) -> nil
+      def did_save: (untyped raw_params) -> nil
+
+      # @rbs (untyped raw_params) -> nil
+      def did_close: (untyped raw_params) -> nil
+    end
+  end
+end

data/sig/ibex/lsp/document_store.rbs

@@ -0,0 +1,94 @@
+# Generated from lib/ibex/lsp/document_store.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Owns open buffers, parsed snapshots, include closures, and reverse dependencies.
+    class DocumentStore
+      include DocumentStoreValidation
+
+      include DocumentStoreDiagnostics
+
+      type snapshot = { uri: String, path: String, version: Integer?, source: String, open: bool, document: Frontend::SourceDocument? }
+
+      type publication = { uri: String, ?version: Integer, diagnostics: Array[WorkspaceAnalyzer::lsp_diagnostic] }
+
+      attr_reader loader: Frontend::SourceLoader
+
+      attr_reader workspace: Workspace
+
+      # @rbs (Workspace workspace, Frontend::SourceLoader loader) -> void
+      def initialize: (Workspace workspace, Frontend::SourceLoader loader) -> void
+
+      # @rbs (String uri, Integer version, String source) -> Array[publication]
+      def open: (String uri, Integer version, String source) -> Array[publication]
+
+      # @rbs (String uri, Integer version, String source) -> Array[publication]
+      def change: (String uri, Integer version, String source) -> Array[publication]
+
+      # @rbs (String uri, ?source: String?) -> Array[publication]
+      def save: (String uri, ?source: String?) -> Array[publication]
+
+      # Clear the open version first, then replace it with a disk snapshot if one exists.
+      # @rbs (String uri) -> Array[publication]
+      def close: (String uri) -> Array[publication]
+
+      # @rbs (String path) -> snapshot?
+      def snapshot_for: (String path) -> snapshot?
+
+      # Preserve the URI spelling used to open a document; closed files use their canonical URI.
+      # @rbs (String path) -> String
+      def uri_for: (String path) -> String
+
+      # @rbs (String path) -> Array[String]
+      def files_for: (String path) -> Array[String]
+
+      # @rbs (String path) -> Array[Frontend::Resolution]
+      def resolutions_for: (String path) -> Array[Frontend::Resolution]
+
+      # @rbs (String path) -> Array[String]
+      def roots_for: (String path) -> Array[String]
+
+      private
+
+      # @rbs (String path) -> Array[publication]
+      def refresh: (String path) -> Array[publication]
+
+      # @rbs (String path) -> Array[publication]
+      def refresh_dependents: (String path) -> Array[publication]
+
+      # @rbs (String root) -> void
+      def refresh_root: (String root) -> void
+
+      # @rbs () -> void
+      def rebuild_reverse_dependencies: () -> void
+
+      # @rbs (String path) -> Array[String]
+      def affected_roots: (String path) -> Array[String]
+
+      # @rbs (String path, WorkspaceAnalyzer::analyzed_document analyzed, ?own_diagnostics: bool) -> void
+      def update_snapshot: (String path, WorkspaceAnalyzer::analyzed_document analyzed, ?own_diagnostics: bool) -> void
+
+      # @rbs (String path, Frontend::SourceDocument? document) -> void
+      def update_root_membership: (String path, Frontend::SourceDocument? document) -> void
+
+      # @rbs (Array[String] paths) -> Array[publication]
+      def publish_paths: (Array[String] paths) -> Array[publication]
+
+      # @rbs (String uri, String path, Integer? version, String source, bool open,
+      #   Frontend::SourceDocument? document) -> snapshot
+      def snapshot: (String uri, String path, Integer? version, String source, bool open, Frontend::SourceDocument? document) -> snapshot
+
+      # @rbs (String path, String uri) -> snapshot
+      def open_snapshot: (String path, String uri) -> snapshot
+
+      # @rbs () -> Array[String]
+      def empty_paths: () -> Array[String]
+
+      # @rbs (String path) -> void
+      def remove_path: (String path) -> void
+
+      # @rbs (String path) -> void
+      def remove_root_state: (String path) -> void
+    end
+  end
+end

data/sig/ibex/lsp/document_store_diagnostics.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/ibex/lsp/document_store_diagnostics.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Owns per-document and per-root diagnostic aggregation for DocumentStore.
+    module DocumentStoreDiagnostics
+      private
+
+      # @rbs (String root, Array[String] files, Hash[String, WorkspaceAnalyzer::analyzed_document] analyzed,
+      #   Array[WorkspaceAnalyzer::lsp_diagnostic] errors) -> void
+      def replace_root_diagnostics: (String root, Array[String] files, Hash[String, WorkspaceAnalyzer::analyzed_document] analyzed, Array[WorkspaceAnalyzer::lsp_diagnostic] errors) -> void
+
+      # @rbs (String path) -> Array[WorkspaceAnalyzer::lsp_diagnostic]
+      def aggregated_diagnostics: (String path) -> Array[WorkspaceAnalyzer::lsp_diagnostic]
+
+      # @rbs () -> Array[WorkspaceAnalyzer::lsp_diagnostic]
+      def empty_diagnostics: () -> Array[WorkspaceAnalyzer::lsp_diagnostic]
+    end
+  end
+end

data/sig/ibex/lsp/document_store_validation.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/ibex/lsp/document_store_validation.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Validates versions, source bounds, and prospective multi-file workspace edits.
+    module DocumentStoreValidation
+      # @rbs (Hash[String, String] replacements) -> bool
+      def valid_replacements?: (Hash[String, String] replacements) -> bool
+
+      private
+
+      # @rbs (Integer version) -> void
+      def validate_version: (Integer version) -> void
+
+      # @rbs (String source) -> void
+      def validate_source: (String source) -> void
+
+      # @rbs (String path, String source) -> void
+      def parse_candidate: (String path, String source) -> void
+
+      # Resolve disk independently from overlay aliases before removing an open buffer.
+      # @rbs (String path, String uri) -> String?
+      def disk_path_for_close: (String path, String uri) -> String?
+    end
+  end
+end

data/sig/ibex/lsp/initialization_handlers.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/ibex/lsp/initialization_handlers.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Handles initialize/initialized/shutdown/exit lifecycle transitions.
+    module InitializationHandlers
+      include RequestSupport
+
+      private
+
+      # @rbs (untyped raw_params) -> Hash[String, untyped]
+      def initialize_workspace: (untyped raw_params) -> Hash[String, untyped]
+
+      # @rbs (untyped params) -> nil
+      def initialized_notification: (untyped params) -> nil
+
+      # @rbs (untyped params) -> nil
+      def shutdown_request: (untyped params) -> nil
+
+      # @rbs (untyped params) -> nil
+      def exit_notification: (untyped params) -> nil
+
+      # @rbs () -> Hash[String, untyped]
+      def capabilities: () -> Hash[String, untyped]
+
+      # @rbs (Hash[String, untyped] params) -> Array[String]
+      def initialization_roots: (Hash[String, untyped] params) -> Array[String]
+    end
+  end
+end

data/sig/ibex/lsp/navigation_handlers.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/ibex/lsp/navigation_handlers.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Serves symbol navigation, rename, and hover requests.
+    module NavigationHandlers
+      include RequestSupport
+
+      private
+
+      # @rbs (untyped raw_params) -> Array[Hash[String, untyped]]
+      def definition: (untyped raw_params) -> Array[Hash[String, untyped]]
+
+      # @rbs (untyped raw_params) -> Array[Hash[String, untyped]]
+      def references: (untyped raw_params) -> Array[Hash[String, untyped]]
+
+      # @rbs (untyped raw_params) -> Hash[String, untyped]?
+      def prepare_rename: (untyped raw_params) -> Hash[String, untyped]?
+
+      # @rbs (untyped raw_params) -> Hash[String, untyped]
+      def rename: (untyped raw_params) -> Hash[String, untyped]
+
+      # @rbs (untyped raw_params) -> Hash[String, untyped]?
+      def hover: (untyped raw_params) -> Hash[String, untyped]?
+
+      # @rbs (untyped raw_params) { (SymbolIndex, String, Hash[String, untyped]) -> untyped } -> untyped
+      def with_index: (untyped raw_params) { (SymbolIndex, String, Hash[String, untyped]) -> untyped } -> untyped
+    end
+  end
+end

data/sig/ibex/lsp/position_codec.rbs

@@ -0,0 +1,40 @@
+# Generated from lib/ibex/lsp/position_codec.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Converts between frontend byte offsets and zero-based LSP UTF-16 positions.
+    class PositionCodec
+      # @rbs (String source) -> void
+      def initialize: (String source) -> void
+
+      # @rbs (Integer byte_offset) -> Hash[String, Integer]
+      def position: (Integer byte_offset) -> Hash[String, Integer]
+
+      # @rbs (Hash[String, untyped] position) -> Integer
+      def byte_offset: (Hash[String, untyped] position) -> Integer
+
+      # @rbs (Frontend::SourceSpan span) -> Hash[String, Hash[String, Integer]]
+      def range: (Frontend::SourceSpan span) -> Hash[String, Hash[String, Integer]]
+
+      private
+
+      # @rbs () -> Array[Integer]
+      def build_line_starts: () -> Array[Integer]
+
+      # @rbs (Integer line) -> Integer
+      def content_end: (Integer line) -> Integer
+
+      # @rbs (String text) -> Integer
+      def utf16_length: (String text) -> Integer
+
+      # @rbs (String text, Integer units) -> Integer
+      def byte_length_at_utf16: (String text, Integer units) -> Integer
+
+      # @rbs (Hash[String, untyped] position, String name) -> Integer
+      def integer_member: (Hash[String, untyped] position, String name) -> Integer
+
+      # @rbs (Integer byte_offset) -> void
+      def validate_byte_offset: (Integer byte_offset) -> void
+    end
+  end
+end

data/sig/ibex/lsp/protocol_error.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/ibex/lsp/protocol_error.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Resource bounds shared by transport and open-document validation.
+    module Limits
+      MAX_HEADER_BYTES: untyped
+
+      MAX_MESSAGE_BYTES: untyped
+
+      MAX_DOCUMENT_BYTES: untyped
+
+      MAX_OUTPUT_BYTES: untyped
+
+      MAX_ERROR_MESSAGE_CHARACTERS: ::Integer
+
+      MAX_REQUEST_ID_BYTES: ::Integer
+    end
+
+    # Bounded protocol and workspace failures with their JSON-RPC error code.
+    class ProtocolError < Ibex::Error
+      attr_reader code: Integer
+
+      attr_reader request_id: String | Integer | nil
+
+      attr_reader fatal: bool
+
+      # @rbs (String message, ?code: Integer, ?request_id: String | Integer | nil, ?fatal: bool) -> void
+      def initialize: (String message, ?code: Integer, ?request_id: String | Integer | nil, ?fatal: bool) -> void
+    end
+  end
+end

data/sig/ibex/lsp/request_handlers.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/ibex/lsp/request_handlers.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Dispatches the finite LSP surface to focused lifecycle, document, and navigation handlers.
+    module RequestHandlers
+      include InitializationHandlers
+
+      include DocumentHandlers
+
+      include NavigationHandlers
+
+      include RequestSupport
+
+      HANDLERS: Hash[String, Symbol]
+
+      private
+
+      # @rbs (String method, untyped params) -> untyped
+      def dispatch: (String method, untyped params) -> untyped
+
+      # @rbs (untyped params) -> nil
+      def cancel_request: (untyped params) -> nil
+    end
+  end
+end

data/sig/ibex/lsp/request_support.rbs

@@ -0,0 +1,40 @@
+# Generated from lib/ibex/lsp/request_support.rb with RBS::Inline
+
+module Ibex
+  module LSP
+    # Shared publication, state, and parameter validation for request handlers.
+    module RequestSupport
+      private
+
+      # @rbs (Array[DocumentStore::publication] publications) -> void
+      def publish: (Array[DocumentStore::publication] publications) -> void
+
+      # @rbs (String uri, Integer version) -> bool
+      def stale_publication?: (String uri, Integer version) -> bool
+
+      # @rbs (untyped value) -> Hash[String, untyped]
+      def params_hash: (untyped value) -> Hash[String, untyped]
+
+      # @rbs (Hash[String, untyped] value, String name) -> Hash[String, untyped]
+      def hash_member: (Hash[String, untyped] value, String name) -> Hash[String, untyped]
+
+      # @rbs (Hash[String, untyped] value, String name) -> String
+      def string_member: (Hash[String, untyped] value, String name) -> String
+
+      # @rbs (Hash[String, untyped] value, String name) -> Integer
+      def integer_member: (Hash[String, untyped] value, String name) -> Integer
+
+      # @rbs (Symbol state) -> void
+      def require_state!: (Symbol state) -> void
+
+      # @rbs () -> void
+      def require_running!: () -> void
+
+      # @rbs () -> DocumentStore
+      def store: () -> DocumentStore
+
+      # @rbs () -> Workspace
+      def workspace: () -> Workspace
+    end
+  end
+end