module RaaP
  type symbolic_call = [:call, untyped, Symbol, Array[untyped], Hash[Symbol, untyped], Proc?]
  VERSION: String

  def self.logger: () -> ::Logger
  def self.logger=: (::Logger) -> void

  module BindCall
    def self.define_method: (untyped, Symbol) { (*untyped, **untyped) -> untyped } -> void
    def self.respond_to?: (untyped, untyped, ?boolish) -> bool
    def self.instance_of?: (untyped, Module) -> bool
    def self.is_a?: (untyped, Module) -> bool
    def self.extend: (untyped, Module) -> void
    def self.name: (Module) -> String?
    def self.to_s: (untyped) -> String
    def self.class: (untyped) -> untyped
    def self.inspect: (untyped) -> String
  end

  class CLI
    class Option < ::Struct[untyped]
      def self.new: (?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool, ?coverage: bool) -> instance

      def self.[]: (?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool, ?coverage: bool) -> instance

      def self.keyword_init?: () -> true

      def self.members: () -> [ :timeout, :size_from, :size_to, :size_by, :allow_private, :coverage]

      def members: () -> [ :timeout, :size_from, :size_to, :size_by, :allow_private, :coverage]

      attr_accessor timeout: (Integer | Float | nil)

      attr_accessor size_from: ::Integer

      attr_accessor size_to: ::Integer

      attr_accessor size_by: ::Integer

      attr_accessor allow_private: bool

      attr_accessor coverage: bool
    end

    type property_result = [Integer, Symbol, ::RBS::MethodType, StringIO?]

    DEFAULT_SKIP: ::Set[String]

    @argv: Array[String]
    @option: Option
    @results:  Array[{ method: ::RBS::Definition::Method, properties: Array[property_result] }]
    @skip: ::Set[::String]

    def self.option: () -> Option
    def self.option=: (Option) -> void

    def initialize: (Array[String]) -> void
    def load: () -> self
    def run: () -> Integer

    private

    def run_by: (kind: (:instance | :singleton), tag: String) -> void
    def run_by_type_name: (tag: String) -> void
    def run_by_type_name_with_search: (tag: String) -> void
    def property: (receiver_type: Type, type_params_decl: Array[::RBS::AST::TypeParam], type_args: Array[::RBS::Types::t], method_name: Symbol, method_type: ::RBS::MethodType) -> property_result
    def report: () -> Integer
  end

  module Coverage
    type locs = [::RBS::Buffer::loc, ::RBS::Buffer::loc]
    class Writer
      @method_type: ::RBS::MethodType
      @cov: ::Set[Symbol]
      @cur: Integer

      def initialize: (::RBS::MethodType, Set[Symbol]) -> void
      def write: (IO) -> void

      private

      def method_type_location: () -> ::RBS::Location[untyped, untyped]
      def slice: (Integer, Range[Integer]) -> String
      def write_param: (IO, String, ::RBS::Types::Function::Param) -> void
      def write_type: (IO, String, ::RBS::Types::t) -> void
      def green: (String) -> String
      def red: (String) -> String
    end

    self.@cov: Set[Symbol]?
    self.@method_type: ::RBS::MethodType

    def self.start: (::RBS::MethodType) -> void
    def self.running?: () -> bool
    def self.log: (String | Symbol) -> void
    def self.cov: () -> Set[Symbol]
    def self.show: (IO) -> void
    def self.new_type_with_log: (String, ::RBS::Types::t) -> Type
    def self.log_with_type: (String, ::RBS::Types::t) -> nil
                          | (String, ::RBS::Types::t) ?{ (::RBS::Types::t) -> Type } -> Type
  end

  class FunctionType
    @fun: ::RBS::Types::Function
    @coverage: boolish

    def initialize: (::RBS::Types::Function, ?coverage: boolish) -> void
    def pick_arguments: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped]]
    def arguments_to_symbolic_call: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped]]

    private

    def to_symbolic_call_recursive: (untyped, size: Integer) -> untyped
    def build_args_type: () -> Array[Type]
    def build_kwargs_type: () -> Hash[Symbol, Type]
    def build_type_with_coverage: (String, ::RBS::Types::Function::Param) -> Type
  end

  class MethodProperty
    class Stats
      attr_accessor success: Integer
      attr_accessor skip: Integer
      attr_accessor exception: Integer
      attr_accessor break: bool
    end

    @receiver_type: Type
    @method_name: Symbol
    @method_type: MethodType
    @size_step: _Each[Integer]
    @timeout: (Integer | Float | nil)
    @allow_private: bool

    def initialize: (receiver_type: Type, method_name: Symbol, method_type: MethodType, size_step: _Each[Integer], timeout: (Integer | Float | nil), ?allow_private: bool) -> void
    def run: () { (Result::Success | Result::Failure | Result::Skip | Result::Exception) -> void } -> Stats

    private

    def call: (size: Integer, stats: Stats) -> (Result::Success | Result::Failure | Result::Skip | Result::Exception)
    def check_return: (receiver_value: untyped, return_value: untyped) -> ([Symbol] | [Symbol, Exception])
    def return_type: () -> RBS::Types::t
    def original_return_type: () -> RBS::Types::t
    def coverage: (String, untyped, RBS::Types::t, ?RBS::Test::TypeCheck?) -> void
  end

  class MethodType
    attr_reader rbs: ::RBS::MethodType
    @fun_type: FunctionType
    @type_check: ::RBS::Test::TypeCheck

    def initialize: (::RBS::MethodType | String method, ?type_params_decl: Array[untyped], ?type_args: Array[untyped], ?self_type: ::RBS::Types::ClassInstance?, ?instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> void
    def pick_arguments: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped], ::Proc?]
    def arguments_to_symbolic_call: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped], ::Proc?]
    def pick_block: (?size: Integer) -> ::Proc?
    def check_return: (untyped) -> bool
  end

  module Minitest
  end

  module RBS
    self.@builder: ::RBS::DefinitionBuilder
    self.@env: ::RBS::Environment
    self.@loader: ::RBS::EnvironmentLoader

    def self.builder: () -> ::RBS::DefinitionBuilder
    def self.env: () -> ::RBS::Environment
    def self.loader: () -> ::RBS::EnvironmentLoader
    def self.parse_type: (String) -> ::RBS::Types::t
    def self.parse_method_type: (String) -> ::RBS::MethodType
    def self.parse_member: (String) -> ::RBS::AST::Members::Attribute
    def self._shift_location: (untyped, Integer) -> void
    def self.find_alias_decl: (::RBS::TypeName, Symbol) -> ::RBS::AST::Members::Alias?
  end

  module Result
    interface _ReturnValue
      def return_value: () -> untyped
    end

    module ReturnValueWithType : _ReturnValue
      def return_value_with_type: () -> String

      private

      def return_value_to_type: (untyped) -> String
    end

    class Success < Data
      include ReturnValueWithType
      def self.new: (symbolic_call: symbolic_call, return_value: untyped) -> instance
      attr_reader symbolic_call: symbolic_call
      attr_reader return_value: untyped
      def called_str: () -> String
    end
    class Failure < Data
      include ReturnValueWithType
      def self.new: (symbolic_call: symbolic_call, return_value: untyped, ?exception: ::Exception?) -> instance
      attr_reader symbolic_call: symbolic_call
      attr_reader return_value: untyped
      attr_reader exception: ::Exception?
      def called_str: () -> String
    end
    class Skip < Data
      def self.new: (symbolic_call: symbolic_call?, exception: ::Exception) -> instance
      attr_reader symbolic_call: symbolic_call?
      attr_reader exception: ::Exception
    end
    class Exception < Data
      def self.new: (symbolic_call: symbolic_call?, exception: ::Exception) -> instance
      attr_reader symbolic_call: symbolic_call?
      attr_reader exception: ::Exception
    end
  end

  class Sized[T]
    @block: ::Proc
    @such_that: ::Proc?

    def initialize: () { (Integer) -> untyped } -> void
    def pick: (size: Integer) -> T
    def such_that: () { (untyped) -> boolish } -> self
    def such_that_loop: [R] () { (Integer) -> R } -> R
  end

  class SymbolicCaller
    class Var
      attr_reader name: String
      def initialize: (String name) -> void
      def +: (String) -> String
      def to_s: () -> String
    end

    attr_reader symbolic_call: untyped
    attr_reader allow_private: bool

    def initialize: (untyped, ?allow_private: bool) -> void
    def eval: () -> untyped
    def call_str: () -> String
    def to_lines: () -> Array[String]

    private

    def try_eval: (untyped) -> untyped
    def walk: () ?{ (symbolic_call) -> untyped} -> untyped
    def _walk: (untyped, bool is_last) ?{ (symbolic_call) -> untyped} -> untyped
    def eval_one: (symbolic_call) -> untyped
    def var_name: (Module) -> String
    def printable?: (untyped) -> bool
    def printable: (untyped) -> String
  end

  class TypeSubstitution
    @type_params: ::Array[::RBS::AST::TypeParam]
    @type_args: ::Array[::RBS::Types::t]

    def initialize: (::Array[::RBS::AST::TypeParam], ::Array[::RBS::Types::t]) -> void
    def build: () -> ::RBS::Substitution
    def method_type_sub: (::RBS::MethodType, ?self_type: ::RBS::Types::t?, ?instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> ::RBS::MethodType

    private

    interface _MapType
      def map_type: { (untyped) -> untyped } -> untyped
    end

    def sub: (_MapType search, self_type: ::RBS::Types::t?, instance_type: ::RBS::Types::t?, class_type: ::RBS::Types::t?) -> untyped
  end

  class Type
    module Arithmetic
      def self.float: () -> Float
      def self.positive_float: () -> Float
    end

    @such_that: (^(untyped) -> ::boolish)?

    GENERATORS: Hash[String, ^() -> Sized[untyped]]
    SIMPLE_SOURCE: Array[String]

    def self.register: (String) { () [self: instance] -> untyped } -> void
    def self.random: () -> Type
    def self.random_without_basic_object: () -> Type
    def self.call_new_from: (Module, ::RBS::Types::ClassInstance, size: Integer) -> symbolic_call

    attr_reader type: ::RBS::Types::t
    attr_reader range: Range[untyped]

    def initialize: (String | ::RBS::Types::t, ?range: Range[untyped]) -> void

    # Define rule for generating values
    #     type.such_that { |i| i != 0 }.pick #=> ensure that the value is not 0
    def such_that: () { (untyped) -> boolish } -> self

    # Basic API for materializing values
    def pick: (?size: Integer) -> untyped
    def to_symbolic_caller: (?size: Integer) -> SymbolicCaller
    def to_symbolic_call: (?size: Integer) -> untyped
    def sized: [T] () { (Integer size) -> T } -> Sized[T]

    private

    def to_symbolic_call_from_initialize: (::RBS::Types::ClassInstance, size: Integer) -> (symbolic_call | Value::Module)
    def parse: (String | ::RBS::Types::t) -> ::RBS::Types::t?
    def try: (times: Integer, size: Integer) { (Integer size) -> untyped } -> untyped

    def numeric: () -> Sized[Numeric]
    def integer: () -> Sized[Integer]
    def none_zero_integer: () -> Sized[Integer]
    def float: () -> Sized[Float]
    def rational: () -> Sized[symbolic_call]
    def complex: () -> Sized[symbolic_call]
    def string: () -> Sized[String]
    def symbol: () -> Sized[Symbol]
    def array: (Type) -> Sized[Array[untyped]]
    def dict: (Type, Type) -> Sized[Hash[untyped, untyped]]
    def encoding: () -> symbolic_call
    def bool: () -> bool
    def temp_method_object: () -> ::Method
  end

  module Value
    class Bottom < BasicObject
      def inspect: () -> String
      def class: () -> class
    end

    class Interface
      @type: ::RBS::Types::Interface
      @size: Integer
      @definition: ::RBS::Definition

      def self.define_method_from_interface: (::Module base_class, String | ::RBS::Types::Interface type, ?size: Integer) -> void
      def initialize: (String | ::RBS::Types::Interface | String, ?size: Integer) -> void
      def respond_to?: (Symbol, ?boolish) -> bool
      def inspect: () -> String
      def class: () -> class
    end

    module Intersection
      @type: ::RBS::Types::Intersection
      @children: Array[Type]
      @size: Integer

      def initialize: (::RBS::Types::Intersection | String, ?size: Integer) -> void
      def respond_to?: (Symbol, ?boolish) -> bool
      def inspect: () -> String
      def class: () -> class
    end

    class Module < BasicObject
      @type: ::RBS::Types::ClassInstance
      @size: Integer
      @self_type: untyped

      def initialize: (::RBS::Types::ClassInstance | String, ?size: Integer) -> void
      def respond_to?: (Symbol, ?boolish) -> bool
      def inspect: () -> String
      def class: () -> class
    end

    class Top < BasicObject
      def inspect: () -> String
      def class: () -> class
    end

    class Variable
      attr_reader type: ::RBS::Types::Variable

      def initialize: (::RBS::Types::Variable | String | Symbol) -> void
      def inspect: () -> String
      def class: () -> class
    end

    class Void < BasicObject
      def inspect: () -> String
      def class: () -> class
    end
  end
end