json_p3 0.4.0 → 1.0.0

data/sig/json_p3.rbs

@@ -1,1325 +1,36 @@
 # JSONPath, JSON Patch and JSON Pointer for Ruby
 module JSONP3
-  DefaultEnvironment: JSONPathEnvironment
+  VERSION: String
+
+  module Path
+    DefaultEnvironment: JSONP3::Path::Environment
+
+    def self.find: (String path, untyped data) -> JSONP3::Path::NodeList
+                
+    def self.find_enum: (String path, untyped data) -> Enumerable[JSONP3::Path::Node]
+
+    def self.compile: (String path) -> JSONP3::Path::Query
+                    
+    def self.match: (String path, untyped data) -> (JSONP3::Path::Node | nil)
+                  
+    def self.first: (String path, untyped data) -> (JSONP3::Path::Node | nil)
+                  
+    def self.match?: (String path, untyped data) -> bool
+  end
 
-  def self.find: (String path, untyped data) -> JSONPathNodeList
-               
-  def self.find_enum: (String path, untyped data) -> Enumerable[JSONPathNode]
+  def self.find: (String path, untyped data) -> JSONP3::Path::NodeList
+                
+  def self.find_enum: (String path, untyped data) -> Enumerable[JSONP3::Path::Node]
 
-  def self.compile: (String path) -> JSONPath
+  def self.compile: (String path) -> JSONP3::Path::Query
                   
-  def self.match: (String path, untyped data) -> (JSONPathNode | nil)
+  def self.match: (String path, untyped data) -> (JSONP3::Path::Node | nil)
                 
-  def self.first: (String path, untyped data) -> (JSONPathNode | nil)
+  def self.first: (String path, untyped data) -> (JSONP3::Path::Node | nil)
                 
   def self.match?: (String path, untyped data) -> bool
                   
   def self.resolve: (String pointer, untyped value, ?default: untyped) -> untyped
 
-  def self.apply: (Array[Op | Hash[String, untyped]] ops, untyped value) -> untyped
-end
-
-module JSONP3
-  # A least recently used cache relying on Ruby hash insertion order.
-  class LRUCache
-    @data: Hash[untyped, untyped]
-
-    @max_size: Integer
-
-    attr_reader max_size: Integer
-
-    def initialize: (Integer max_size) -> void
-
-    # Return the cached value or nil if _key_ does not exist.
-    def []: (untyped key) -> (nil | untyped)
-
-    def []=: (untyped key, untyped value) -> untyped
-
-    def length: () -> Integer
-
-    def keys: () -> Array[untyped]
-  end
-end
-
-module JSONP3
-  # JSONPath configuration
-  class JSONPathEnvironment
-    MAX_INT_INDEX: Numeric
-
-    MIN_INT_INDEX: Numeric
-
-    MAX_RECURSION_DEPTH: Integer
-
-    # XXX: I don't known how to specify a class rather than a class instance.
-    NAME_SELECTOR: untyped
-
-    INDEX_SELECTOR: untyped
-
-    @parser: Parser
-
-    @function_extensions: Hash[String, FunctionExtension]
-
-    attr_accessor function_extensions: Hash[String, FunctionExtension]
-
-    def initialize: () -> void
-
-    # Prepare JSONPath expression _query_ for repeated application.
-    # @param query [String]
-    # @return [JSONPath]
-    def compile: (String query) -> JSONPath
-
-    # Apply JSONPath expression _query_ to _value_.
-    # @param query [String]
-    # @param value [JSON-like data]
-    # @return [Array<JSONPath>]
-    def find: (String query, untyped value) -> JSONPathNodeList
-            
-    def find_enum: (String query, untyped value) -> Enumerable[JSONPathNode]
-                 
-    def match: (String query, untyped value) -> (JSONPathNode | nil)
-             
-    def match?: (String query, untyped value) -> bool
-              
-    def first: (String query, untyped value) -> (JSONPathNode | nil)
-
-    def setup_function_extensions: () -> void
-  end
-end
-
-module JSONP3
-  # An exception raised when a JSONPathEnvironment is misconfigured.
-  class JSONPathEnvironmentError < StandardError
-  end
-
-  # Base class for JSONPath exceptions that happen when parsing or evaluating a query.
-  class JSONPathError < StandardError
-    FULL_MESSAGE: bool
-    
-    @token: Token
-
-    def initialize: (String msg, Token token) -> void
-  end
-
-  class JSONPathSyntaxError < JSONPathError
-  end
-
-  class JSONPathTypeError < JSONPathError
-  end
-
-  class JSONPathNameError < JSONPathError
-  end
-
-  class JSONPathRecursionError < JSONPathError
-  end
-
-  class JSONPointerError < StandardError
-  end
-
-  class JSONPointerIndexError < JSONPointerError
-  end
-
-  class JSONPointerSyntaxError < JSONPointerError
-  end
-
-  class JSONPointerTypeError < JSONPointerError
-  end
-
-  class JSONPatchError < StandardError
-  end
-
-  class JSONPatchTestFailure < JSONPatchError
-  end
-  
-end
-
-module JSONP3
-  # Base class for all filter expression nodes.
-  class Expression
-    @token: Token
-
-    # @dynamic token
-    attr_reader token: Token
-
-    def initialize: (Token token) -> void
-
-    # Evaluate the filter expression in the given context.
-    def evaluate: (FilterContext _context) -> untyped
-  end
-
-  # An expression that evaluates to true or false.
-  class FilterExpression < Expression
-    @expression: Expression
-
-    attr_reader expression: Expression
-
-    def initialize: (Token token, Expression expression) -> void
-
-    def evaluate: (FilterContext context) -> untyped
-
-    def to_s: () -> String
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-            
-    private
-
-    class Precedence
-      LOWEST: 1
-  
-      LOGICAL_OR: 3
-  
-      LOGICAL_AND: 4
-  
-      PREFIX: 7
-    end
-
-    def to_canonical_string: (Expression expression, Integer parent_precedence) -> String
-  end
-
-  # Base class for expression literals.
-  class FilterExpressionLiteral < Expression
-    @value: untyped
-
-    attr_reader value: untyped
-
-    def initialize: (Token token, untyped value) -> void
-
-    def evaluate: (FilterContext _context) -> untyped
-
-    def to_s: () -> String
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-  end
-
-  # Literal true or false.
-  class BooleanLiteral < FilterExpressionLiteral
-  end
-
-  # A double or single quoted string literal.
-  class StringLiteral < FilterExpressionLiteral
-    def to_s: () -> String
-  end
-
-  # A literal integer.
-  class IntegerLiteral < FilterExpressionLiteral
-  end
-
-  # A literal float
-  class FloatLiteral < FilterExpressionLiteral
-  end
-
-  # A literal null
-  class NullLiteral < FilterExpressionLiteral
-    def to_s: () -> "null"
-  end
-
-  # An expression prefixed with the logical not operator.
-  class LogicalNotExpression < Expression
-    @expression: Expression
-
-    attr_reader expression: Expression
-
-    def initialize: (Token token, Expression expression) -> void
-
-    def evaluate: (FilterContext context) -> untyped
-
-    def to_s: () -> ::String
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-  end
-
-  # Base class for expression with a left expression, operator and right expression.
-  class InfixExpression < Expression
-    @left: Expression
-
-    @right: Expression
-
-    attr_reader left: Expression
-
-    attr_reader right: Expression
-
-    def initialize: (Token token, Expression left, Expression right) -> void
-
-    def evaluate: (FilterContext _context) -> untyped
-
-    def to_s: () -> String
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-  end
-
-  # A logical `&&` expression.
-  class LogicalAndExpression < InfixExpression
-    def evaluate: (FilterContext context) -> untyped
-
-    def to_s: () -> ::String
-  end
-
-  # A logical `||` expression.
-  class LogicalOrExpression < InfixExpression
-    def evaluate: (FilterContext context) -> untyped
-
-    def to_s: () -> ::String
-  end
-
-  # An `==` expression.
-  class EqExpression < InfixExpression
-    def evaluate: (FilterContext context) -> untyped
-
-    def to_s: () -> ::String
-  end
-
-  # A `!=` expression.
-  class NeExpression < InfixExpression
-    def evaluate: (FilterContext context) -> untyped
-
-    def to_s: () -> ::String
-  end
-
-  # A `<=` expression.
-  class LeExpression < InfixExpression
-    def evaluate: (FilterContext context) -> untyped
-
-    def to_s: () -> ::String
-  end
-
-  # A `>=` expression.
-  class GeExpression < InfixExpression
-    def evaluate: (FilterContext context) -> untyped
-
-    def to_s: () -> ::String
-  end
-
-  # A `<` expression.
-  class LtExpression < InfixExpression
-    def evaluate: (FilterContext context) -> untyped
-
-    def to_s: () -> ::String
-  end
-
-  # A `>` expression.
-  class GtExpression < InfixExpression
-    def evaluate: (FilterContext context) -> untyped
-
-    def to_s: () -> ::String
-  end
-
-  # Base class for all embedded filter queries
-  class QueryExpression < Expression
-    @query: JSONPath
-
-    attr_reader query: JSONPath
-
-    def initialize: (Token token, JSONPath query) -> void
-
-    def evaluate: (FilterContext _context) -> untyped
-
-    def to_s: () -> String
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-  end
-
-  # An embedded query starting at the current node.
-  class RelativeQueryExpression < QueryExpression
-    def evaluate: (FilterContext context) -> untyped
-
-    def to_s: () -> ::String
-  end
-
-  # An embedded query starting at the root node.
-  class RootQueryExpression < QueryExpression
-    def evaluate: (FilterContext context) -> untyped
-
-    def to_s: () -> String
-  end
-
-  # A filter function call.
-  class FunctionExpression < Expression
-    @name: String
-
-    @args: Array[Expression]
-
-    attr_reader name: String
-
-    attr_reader args: Array[Expression]
-
-    # @param name [String]
-    # @param args [Array<Expression>]
-    def initialize: (Token token, String name, Array[Expression] args) -> void
-
-    def evaluate: (FilterContext context) -> untyped
-
-    def to_s: () -> ::String
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-
-    private
-
-    def unpack_node_lists: (FunctionExtension func, Array[untyped] args) -> Array[untyped]
-  end
-
-  def self.truthy?: (untyped obj) -> bool
-
-  def self.eq?: (Expression left, Expression right) -> bool
-
-  def self.lt?: (Expression left, Expression right) -> bool
-
-  # Contextual information and data used for evaluating a filter expression.
-  class FilterContext
-    @env: JSONPathEnvironment
-
-    @current: untyped
-
-    @root: untyped
-
-    attr_reader env: JSONPathEnvironment
-
-    attr_reader current: untyped
-
-    attr_reader root: untyped
-
-    def initialize: (JSONPathEnvironment env, untyped current, untyped root) -> void
-  end
-end
-
-type expression_t = :value_expression | :logical_expression | :nodes_expression
-
-module JSONP3
-  # Base class for all filter functions.
-  class FunctionExtension
-    ARG_TYPES: Array[expression_t]
-
-    RETURN_TYPE: expression_t
-
-    def call: (*untyped _args, **untyped _kwargs) -> untyped
-  end
-end
-
-module JSONP3
-  # Return an array of tokens for the JSONPath expression _query_.
-  #
-  # @param query [String] the JSONPath expression to tokenize.
-  # @return [Array<Token>]
-  def self.tokenize: (String query) -> Array[Token]
-
-  # JSONPath query expression lexical scanner.
-  #
-  # @see tokenize
-  class Lexer
-    @filter_depth: Integer
-
-    @paren_stack: Array[Integer]
-
-    @tokens: Array[Token]
-
-    @start: Integer
-
-    @query: String
-
-    @scanner: untyped
-
-    RE_INT: ::Regexp
-
-    RE_NAME: ::Regexp
-
-    RE_WHITESPACE: ::Regexp
-
-    S_ESCAPES: Set[String]
-
-    # @dynamic tokens
-    attr_reader tokens: Array[Token]
-
-    def initialize: (String query) -> void
-
-    def run: () -> void
-
-    # Generate a new token with the given type.
-    # @param token_type [Symbol] one of the constants defined on the _Token_ class.
-    # @param value [String | nil] a the token's value, if it is known, otherwise the
-    #   value will be sliced from @query. This is a performance optimization.
-    def emit: (token_t token_type, ?untyped value) -> void
-
-    def next: () -> String
-
-    def ignore: () -> void
-
-    def backup: () -> void
-
-    def peek: () -> String
-
-    # Advance the lexer if the next character is equal to _char_.
-    def accept?: (String | Regexp pattern) -> bool
-
-    # Accept a run of digits, possibly preceded by a negative sign.
-    # Does not handle exponents.
-    def accept_int?: () -> bool
-
-    def ignore_whitespace?: () -> (false | true)
-
-    def error: (String message) -> void
-
-    def lex_root: () -> (nil | :lex_segment)
-
-    def lex_segment: () -> (nil | :lex_shorthand_selector | untyped)
-
-    def lex_descendant_segment: () -> untyped
-
-    def lex_shorthand_selector: () -> (nil | :lex_segment)
-
-    def lex_inside_bracketed_segment: () -> untyped
-
-    def lex_inside_filter: () -> untyped
-
-    def self.lex_string_factory: (String quote, Symbol state, token_t token) -> untyped
-  end
-end
-
-type location_element = String | Integer | Array[location_element]
-
-module JSONP3
-  # A JSON-like value and its location.
-  class JSONPathNode
-    @value: untyped
-
-    @location: Array[location_element]
-
-    @root: untyped
-
-    # @dynamic value, location, root
-    attr_reader value: untyped
-
-    # @dynamic value, location, root
-    attr_reader location: Array[location_element]
-
-    # @dynamic value, location, root
-    attr_reader root: untyped
-
-    # @param value [JSON-like] the value at this node.
-    # @param location [Array<String | Integer | Array<String | Integer>>] the sequence of
-    #   names and/or indices leading to _value_ in _root_.
-    # @param root [JSON-like] the root value containing _value_ at _location_.
-    def initialize: (untyped value, Array[location_element] location, untyped root) -> void
-
-    # Return the normalized path to this node.
-    # @return [String] the normalized path.
-    def path: () -> ::String
-
-    # Return a new node that is a child of this node.
-    # @param value the JSON-like value at the new node.
-    # @param key [Integer, String] the array index or hash key associated with _value_.
-    def new_child: (untyped value, String | Integer key) -> JSONPathNode
-
-    def to_s: () -> ::String
-  end
-
-  # An array of JSONPathNode instances.
-  class JSONPathNodeList < Array[JSONPathNode]
-  end
+  def self.apply!: (Array[Patch::Op | Hash[String, untyped]] ops, untyped value) -> untyped
 end
-
-module JSONP3
-  # Step through tokens
-  class Stream
-    @tokens: Array[Token]
-
-    @index: Integer
-
-    @eoi: Token
-
-    def initialize: (Array[Token] tokens) -> void
-
-    def next: () -> Token
-
-    def peek: () -> Token
-
-    def expect: (token_t token_type) -> void
-
-    def expect_not: (token_t token_type, String message) -> void
-
-    def to_s: () -> ::String
-  end
-
-  class Precedence
-    LOWEST: 1
-
-    LOGICAL_OR: 3
-
-    LOGICAL_AND: 4
-
-    RELATIONAL: 5
-
-    PREFIX: 7
-  end
-
-  # A JSONPath expression parser.
-  class Parser
-    @env: JSONPathEnvironment
-
-    @name_selector: untyped
-    
-    @index_selector: untyped
-
-    def initialize: (JSONPathEnvironment env) -> void
-
-    # Parse an array of tokens into an abstract syntax tree.
-    # @param tokens [Array<Token>] tokens from the lexer.
-    # @return [Array<Segment>]
-    def parse: (Array[Token] tokens) -> Array[Segment]
-
-    def parse_query: (Stream stream) -> Array[Segment]
-
-    def parse_selectors: (Stream stream) -> Array[Selector]
-
-    def parse_bracketed_selection: (Stream stream) -> Array[Selector]
-
-    def parse_index_or_slice: (Stream stream) -> Selector
-
-    def parse_slice_selector: (Stream stream) -> Selector
-
-    def parse_filter_selector: (Stream stream) -> Selector
-
-    def parse_filter_expression: (Stream stream, ?Integer precedence) -> Expression
-
-    def parse_integer_literal: (Stream stream) -> Expression
-
-    def parse_float_literal: (Stream stream) -> Expression
-
-    def parse_function_expression: (Stream stream) -> Expression
-
-    def parse_grouped_expression: (Stream stream) -> Expression
-
-    def parse_prefix_expression: (Stream stream) -> Expression
-
-    def parse_root_query: (Stream stream) -> Expression
-
-    def parse_relative_query: (Stream stream) -> Expression
-
-    def parse_infix_expression: (Stream stream, Expression left) -> Expression
-
-    def parse_i_json_int: (Token token) -> Integer
-
-    def decode_string_literal: (Token token) -> String
-
-    def raise_for_non_comparable_function: (Expression expression) -> void
-
-    def raise_for_not_compared_literal: (Expression expression) -> void
-
-    def validate_function_extension_signature: (Token token, untyped args) -> void
-
-    def function_return_type: (Expression expression) -> (expression_t | nil)
-
-    PRECEDENCES: ::Hash[token_t, Integer]
-
-    BINARY_OPERATORS: ::Hash[token_t, "&&" | "||" | "==" | ">=" | ">" | "<=" | "<" | "!="]
-
-    COMPARISON_OPERATORS: Set[String]
-  end
-end
-
-module JSONP3
-  # A compiled JSONPath expression ready to be applied to JSON-like values.
-  class JSONPath
-    @env: JSONPathEnvironment
-
-    @segments: Array[Segment]
-
-    def initialize: (JSONPathEnvironment env, Array[Segment] segments) -> void
-
-    def to_s: () -> ::String
-
-    # Apply this JSONPath expression to JSON-like value _root_.
-    # @param root [Array, Hash, String, Integer] the root JSON-like value to apply this query to.
-    # @return [Array<JSONPathNode>] the sequence of nodes found while applying this query to _root_.
-    def find: (untyped root) -> JSONPathNodeList
-
-    def find_enum: (untyped root) -> Enumerable[JSONPathNode]
-
-    def match: (untyped root) -> (JSONPathNode | nil)
-
-    def match?: (untyped root) -> bool
-
-    def first: (untyped root) -> (JSONPathNode | nil)
-
-    alias apply find
-
-    # Return true if this JSONPath expression is a singular query.
-    def singular?: () -> (false | true)
-
-    # Return true if this JSONPath expression has no segments.
-    def empty?: () -> (false | true)
-  end
-end
-
-module JSONP3
-  # Base class for all JSONPath segments.
-  class Segment
-    @env: JSONPathEnvironment
-
-    @token: Token
-
-    @selectors: Array[Selector]
-
-    # @dynamic token, selectors
-    attr_reader token: Token
-
-    # @dynamic token, selectors
-    attr_reader selectors: Array[Selector]
-
-    def initialize: (JSONPathEnvironment env, Token token, Array[Selector] selectors) -> void
-
-    # Select the children of each node in _nodes_.
-    def resolve: (Array[JSONPathNode] _nodes) -> Array[JSONPathNode]
-
-    # Select the children of each node in _nodes_.
-    def resolve_enum: (Enumerable[JSONPathNode] _nodes) -> Enumerable[JSONPathNode]
-  end
-
-  # The child selection segment.
-  class ChildSegment < Segment
-    def resolve: (Array[JSONPathNode] nodes) -> Array[JSONPathNode]
-               
-    def resolve_enum: (Enumerable[JSONPathNode] nodes) -> Enumerable[JSONPathNode]
-
-    def to_s: () -> ::String
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-  end
-
-  # The recursive descent segment
-  class RecursiveDescentSegment < Segment
-    def resolve: (Array[JSONPathNode] nodes) -> Array[JSONPathNode]
-               
-    def resolve_enum: (Enumerable[JSONPathNode] nodes) -> Enumerable[JSONPathNode]
-
-    def to_s: () -> ::String
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-
-    def visit: (JSONPathNode node, ?::Integer depth) -> Array[JSONPathNode]
-    def visit_enum: (JSONPathNode node, ?::Integer depth) -> Enumerable[JSONPathNode]
-  end
-end
-
-module JSONP3
-  # Base class for all JSONPath selectors
-  class Selector
-    @env: JSONPathEnvironment
-
-    @token: Token
-
-    # @dynamic token
-    attr_reader token: Token
-
-    def initialize: (JSONPathEnvironment env, Token token) -> void
-
-    # Apply this selector to _node_.
-    # @return [Array<JSONPathNode>]
-    def resolve: (JSONPathNode _node) -> Array[JSONPathNode]
-    def resolve_enum: (JSONPathNode _node) -> Enumerable[JSONPathNode]
-
-    # Return true if this selector is a singular selector.
-    def singular?: () -> false
-  end
-
-  # The name selector select values from hashes given a key.
-  class NameSelector < Selector
-    @name: String
-
-    # @dynamic name
-    attr_reader name: String
-
-    def initialize: (JSONPathEnvironment env, Token token, String name) -> void
-
-    def resolve: (JSONPathNode node) -> ::Array[JSONPathNode]
-    def resolve_enum: (JSONPathNode node) -> Enumerable[JSONPathNode]
-
-    def singular?: () -> true
-
-    def to_s: () -> String
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-  end
-
-  class SymbolNameSelector < NameSelector
-    @name: String
-
-    @sym: Symbol
-
-    # @dynamic name
-    attr_reader name: String
-
-    def initialize: (JSONPathEnvironment env, Token token, String name) -> void
-
-    def resolve: (JSONPathNode node) -> ::Array[JSONPathNode]
-    def resolve_enum: (JSONPathNode node) -> Enumerable[JSONPathNode]
-
-    def singular?: () -> true
-
-    def to_s: () -> String
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-  end
-
-  # The index selector selects values from arrays given an index.
-  class IndexSelector < Selector
-    @index: Integer
-
-    # @dynamic index
-    attr_reader index: Integer
-
-    def initialize: (JSONPathEnvironment env, Token token, Integer index) -> void
-
-    def resolve: (JSONPathNode node) -> ::Array[JSONPathNode]
-    def resolve_enum: (JSONPathNode node) -> Enumerable[JSONPathNode]
-
-    def singular?: () -> true
-
-    def to_s: () -> String
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-
-    private
-
-    def normalize: (Integer index, Integer length) -> Integer
-  end
-
-  # The wildcard selector selects all elements from an array or values from a hash.
-  class WildcardSelector < Selector
-    def resolve: (JSONPathNode node) -> ::Array[JSONPathNode]
-    def resolve_enum: (JSONPathNode node) -> Enumerable[JSONPathNode]
-
-    def to_s: () -> "*"
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-  end
-
-  # The slice selector selects a range of elements from an array.
-  class SliceSelector < Selector
-    @start: (Integer | nil)
-
-    @stop: (Integer | nil)
-
-    @step: Integer
-
-    # @dynamic start, stop, step
-    attr_reader start: (Integer | nil)
-
-    # @dynamic start, stop, step
-    attr_reader stop: (Integer | nil)
-
-    # @dynamic start, stop, step
-    attr_reader step: Integer
-
-    def initialize: (JSONPathEnvironment env, Token token, (Integer | nil) start, (Integer | nil) stop, (Integer | nil) step) -> void
-
-    def resolve: (JSONPathNode node) -> ::Array[JSONPathNode]
-    def resolve_enum: (JSONPathNode node) -> Enumerable[JSONPathNode]
-
-    def to_s: () -> ::String
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-  end
-
-  # Select array elements or hash values according to a filter expression.
-  class FilterSelector < Selector
-    @expression: Expression
-
-    # @dynamic expression
-    attr_reader expression: Expression
-
-    def initialize: (JSONPathEnvironment env, Token token, Expression expression) -> void
-
-    def resolve: (JSONPathNode node) -> ::Array[JSONPathNode]
-    def resolve_enum: (JSONPathNode node) -> Enumerable[JSONPathNode]
-
-    def to_s: () -> ::String
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-  end
-end
-
-type token_t = (
-  :token_eoi |
-  :token_error |
-  :token_colon |
-  :token_comma |
-  :token_double_dot |
-  :token_filter |
-  :token_index |
-  :token_lbracket |
-  :token_name |
-  :token_rbracket |
-  :token_root |
-  :token_wild |
-  :token_and |
-  :token_current |
-  :token_double_quote_string |
-  :token_eq |
-  :token_false |
-  :token_float |
-  :token_function |
-  :token_ge |
-  :token_gt |
-  :token_int |
-  :token_le |
-  :token_lparen |
-  :token_lt |
-  :token_ne |
-  :token_not |
-  :token_null |
-  :token_or |
-  :token_rparen |
-  :token_single_quote_string |
-  :token_true
-)
-    
-
-module JSONP3
-  # Tokens are produced by the lexer and consumed by the parser. Each token contains sub
-  # string from a JSONPath expression, its location within the JSONPath expression and a
-  # symbol indicating what type of token it is.
-  class Token
-    @type: token_t
-
-    @value: String
-
-    @start: Integer
-
-    @query: String
-
-    @message: (String | nil)
-
-    # @dynamic type, value, start, query
-    attr_reader type: token_t
-
-    # @dynamic type, value, start, query
-    attr_reader value: String
-
-    # @dynamic type, value, start, query
-    attr_reader start: Integer
-
-    # @dynamic type, value, start, query
-    attr_reader query: String
-
-    # @dynamic type, value, start, query
-    attr_reader message: (String | nil)
-
-    def initialize: (token_t type, String value, Integer start, String query, ?message: (String | nil)?) -> void
-
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    def hash: () -> Integer
-  end
-end
-
-module JSONP3
-  # Replace escape sequences with their equivalent Unicode code point.
-  # @param value [String]
-  # @param quote [String] one of '"' or "'".
-  # @param token [Token]
-  # @return [String] A new string without escape sequences.
-  def self.unescape_string: (String value, String quote, Token token) -> String
-
-  def self.decode_hex_char: (untyped value, untyped index, Token token) -> ::Array[untyped]
-
-  def self.parse_hex_digits: (untyped digits, Token token) -> untyped
-
-  def self.high_surrogate?: (untyped code_point) -> untyped
-
-  def self.low_surrogate?: (untyped code_point) -> untyped
-
-  def self.code_point_to_string: (untyped code_point, Token token) -> untyped
-
-  def self.canonical_string: (untyped String) -> ::String
-end
-
-module JSONP3
-  VERSION: String
-end
-
-module JSONP3
-  # The standard `count` function.
-  class Count < FunctionExtension
-    ARG_TYPES: Array[expression_t]
-
-    RETURN_TYPE: expression_t
-
-    def call: (JSONPathNodeList node_list) -> untyped
-  end
-end
-
-module JSONP3
-  # The standard `length` function.
-  class Length < FunctionExtension
-    ARG_TYPES: Array[expression_t]
-
-    RETURN_TYPE: expression_t
-
-    def call: (untyped obj) -> (:nothing | untyped)
-  end
-end
-
-module JSONP3
-  # The standard `match` function.
-  class Match < FunctionExtension
-    @cache_size: Integer
-
-    @raise_errors: (true | false)
-
-    @cache: LRUCache
-
-    ARG_TYPES: Array[expression_t]
-
-    RETURN_TYPE: expression_t
-
-    # @param cache_size [Integer] the maximum size of the regexp cache. Set it to
-    #   zero or negative to disable the cache.
-    # @param raise_errors [bool] if _false_ (the default), return _false_ when this
-    #   function causes a RegexpError instead of raising the exception.
-    def initialize: (?::Integer cache_size, ?raise_errors: bool) -> void
-
-    # @param value [String]
-    # @param pattern [String]
-    # @return bool
-    def call: (untyped value, untyped pattern) -> untyped
-
-    private
-
-    def full_match: (String pattern) -> String
-  end
-end
-
-module JSONP3
-  # Map I-Regexp pattern to Ruby regex pattern.
-  # @param pattern [String]
-  # @return [String]
-  def self.map_iregexp: (String pattern) -> String
-end
-
-module JSONP3
-  # The standard `search` function.
-  class Search < FunctionExtension
-    @cache_size: Integer
-
-    @raise_errors: (true | false)
-
-    @cache: LRUCache
-
-    ARG_TYPES: Array[expression_t]
-
-    RETURN_TYPE: expression_t
-
-    # @param cache_size [Integer] the maximum size of the regexp cache. Set it to
-    #   zero or negative to disable the cache.
-    # @param raise_errors [bool] if _false_ (the default), return _false_ when this
-    #   function causes a RegexpError instead of raising the exception.
-    def initialize: (?::Integer cache_size, ?raise_errors: bool) -> void
-
-    # @param value [String]
-    # @param pattern [String]
-    # @return bool
-    def call: (untyped value, untyped pattern) -> untyped
-  end
-end
-
-module JSONP3
-  # The standard `value` function.
-  class Value < FunctionExtension
-    ARG_TYPES: Array[expression_t]
-
-    RETURN_TYPE: expression_t
-
-    def call: (JSONPathNodeList node_list) -> (untyped | :nothing)
-  end
-end
-
-module JSONP3
-  # Identify a single value in JSON-like data, as per RFC 6901.
-  class JSONPointer
-    @tokens: Array[String | Integer]
-
-    @pointer: String
-
-    UNDEFINED: :__undefined
-
-    RE_INT: ::Regexp
-
-    attr_reader tokens: Array[String | Integer]
-
-    # Encode an array of strings and integers into a JSON pointer.
-    # @param tokens [Array<String | Integer>]
-    # @return [String]
-    def self.encode: (Array[String | Integer] tokens) -> String
-
-    # @param pointer [String]
-    def initialize: (String pointer) -> void
-
-    # Resolve this pointer against JSON-like data _value_.
-    def resolve: (untyped value, ?default: untyped) -> untyped
-
-    def resolve_with_parent: (untyped value) -> ::Array[untyped]
-
-    def relative_to?: (JSONPointer pointer) -> bool
-
-    # @param parts [String]
-    def join: (*String parts) -> JSONPointer
-            
-    # Return _true_ if this pointer can be resolved against _value_, even if the resolved
-    # value is false or nil.
-    def exist?: (untyped value) -> bool
-
-    # Return this pointer's parent as a new pointer. If this pointer points to the
-    # document root, self is returned.
-    def parent: () -> JSONPointer
-
-    # @param rel [String | RelativeJSONPointer]
-    # @return [JSONPointer]
-    def to: ((String | RelativeJSONPointer) rel) -> JSONPointer
-
-    def to_s: () -> String
-
-    # @param pointer [String]
-    # @return [Array<String | Integer>]
-    def parse: (String pointer) -> Array[(String | Integer)]
-
-    # @param value [Object]
-    # @param token [String | Integer]
-    # @return [Object] the "fetched" object from _value_ or UNDEFINED.
-    def get_item: (untyped value, (String | Integer) token) -> untyped
-
-    # Like `#parse`, but assumes there's no leading slash.
-    # @param pointer [String]
-    # @return [Array<String | Integer>]
-    def _parse: (String pointer) -> Array[(String | Integer)]
-
-    def _join: (String other) -> JSONPointer
-  end
-
-  # A relative JSON Pointer.
-  # See https://datatracker.ietf.org/doc/html/draft-hha-relative-json-pointer
-  class RelativeJSONPointer
-    @origin: Integer
-
-    @index: Integer
-
-    @pointer: (String | JSONPointer)
-
-    RE_RELATIVE_POINTER: ::Regexp
-
-    RE_INT: ::Regexp
-
-    # @param rel [String]
-    def initialize: (String rel) -> void
-
-    def to_s: () -> ::String
-
-    # @param pointer [String | JSONPointer]
-    # @return [JSONPointer]
-    def to: ((String | JSONPointer) pointer) -> JSONPointer
-
-    private
-
-    # @param token [String]
-    # @return [Integer]
-    def parse_int: (String token) -> Integer
-  end
-end
-
-module JSONP3
-  # Base class for all JSON Patch operations
-  class Op
-    # Return the name of the patch operation.
-    def name: () -> String
-
-    # Apply the patch operation to _value_.
-    def apply: (untyped _value, Integer _index) -> untyped
-
-    # Return a JSON-like representation of this patch operation.
-    def to_h: () -> untyped
-  end
-
-  # The JSON Patch _add_ operation.
-  class OpAdd < Op
-    @pointer: JSONPointer
-
-    @value: untyped
-
-    # @param pointer [JSONPointer]
-    # @param value [JSON-like value]
-    def initialize: (JSONPointer pointer, untyped value) -> void
-
-    def name: () -> "add"
-  end
-
-  # The JSON Patch _remove_ operation.
-  class OpRemove < Op
-    @pointer: JSONPointer
-
-    # @param pointer [JSONPointer]
-    def initialize: (JSONPointer pointer) -> void
-
-    def name: () -> "remove"
-  end
-
-  # The JSON Patch _replace_ operation.
-  class OpReplace < Op
-    @pointer: JSONPointer
-
-    @value: untyped
-
-    # @param pointer [JSONPointer]
-    # @param value [JSON-like value]
-    def initialize: (JSONPointer pointer, untyped value) -> void
-
-    def name: () -> "replace"
-  end
-
-  # The JSON Patch _move_ operation.
-  class OpMove < Op
-    @from: JSONPointer
-
-    @pointer: JSONPointer
-
-    # @param from [JSONPointer]
-    # @param pointer [JSONPointer]
-    def initialize: (JSONPointer from, JSONPointer pointer) -> void
-
-    def name: () -> "move"
-  end
-
-  # The JSON Patch _copy_ operation.
-  class OpCopy < Op
-    @from: JSONPointer
-
-    @pointer: JSONPointer
-
-    # @param from [JSONPointer]
-    # @param pointer [JSONPointer]
-    def initialize: (JSONPointer from, JSONPointer pointer) -> void
-
-    def name: () -> "copy"
-            
-    def deep_copy: (untyped obj) -> untyped
-  end
-
-  # The JSON Patch _test_ operation.
-  class OpTest < Op
-    @pointer: JSONPointer
-
-    @value: untyped
-
-    # @param pointer [JSONPointer]
-    # @param value [JSON-like value]
-    def initialize: (JSONPointer pointer, untyped value) -> void
-
-    def name: () -> "test"
-  end
-
-  # A JSON Patch containing zero or more patch operations.
-  class JSONPatch
-    @ops: Array[Op]
-
-    # @param ops [Array<Op>?]
-    def initialize: (?Array[Op | Hash[String, untyped]]? ops) -> void
-
-    # @param pointer [String | JSONPointer]
-    # @param value [JSON-like value]
-    # @return [self]
-    def add: (JSONPointer | String pointer, untyped value) -> self
-
-    # @param pointer [String | JSONPointer]
-    # @return [self]
-    def remove: (JSONPointer | String pointer) -> self
-
-    # @param pointer [String | JSONPointer]
-    # @param value [JSON-like value]
-    # @return [self]
-    def replace: (JSONPointer | String pointer, untyped value) -> self
-
-    # @param from [String | JSONPointer]
-    # @param pointer [String | JSONPointer]
-    # @return [self]
-    def move: (JSONPointer | String from, JSONPointer | String pointer) -> self
-
-    # @param from [String | JSONPointer]
-    # @param pointer [String | JSONPointer]
-    # @return [self]
-    def copy: (JSONPointer | String from, JSONPointer | String pointer) -> self
-
-    # @param pointer [String | JSONPointer]
-    # @param value [JSON-like value]
-    # @return [self]
-    def test: (JSONPointer | String pointer, untyped value) -> self
-
-    # Apply this patch to JSON-like value _value_.
-    def apply: (untyped value) -> untyped
-
-    def to_a: () -> Array[untyped]
-
-    private
-
-    def ensure_pointer: (JSONPointer | String pointer, Symbol op, Integer index) -> JSONPointer
-                      
-    def build: (Array[Op | Hash[String, untyped]]) -> void
-             
-    def op_pointer: (Hash[String, untyped] obj, String key, String op, Integer index) -> JSONPointer
-
-    def op_value: (Hash[String, untyped] obj, String key, String op, Integer index) -> untyped
-  end
-end