# typed: strict

class Prism::Source
  sig { returns(String) }
  def source; end

  sig { returns(Integer) }
  def start_line; end

  sig { returns(T::Array[Integer]) }
  def offsets; end

  sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
  def initialize(source, start_line = 1, offsets = []); end

  sig { params(start_line: Integer).void }
  def replace_start_line(start_line); end

  sig { params(offsets: T::Array[Integer]).void }
  def replace_offsets(offsets); end

  sig { returns(Encoding) }
  def encoding; end

  sig { returns(T::Array[String]) }
  def lines; end

  sig { params(byte_offset: Integer, length: Integer).returns(String) }
  def slice(byte_offset, length); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def line(byte_offset); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def line_start(byte_offset); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def column(byte_offset); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def character_offset(byte_offset); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def character_column(byte_offset); end

  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
  def code_units_offset(byte_offset, encoding); end

  sig { params(encoding: Encoding).returns(T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))) }
  def code_units_cache(encoding); end

  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
  def code_units_column(byte_offset, encoding); end
end

class Prism::CodeUnitsCache
  sig { params(source: String, encoding: Encoding).void }
  def initialize(source, encoding); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def [](byte_offset); end
end

class Prism::ASCIISource < Prism::Source
  sig { params(byte_offset: Integer).returns(Integer) }
  def character_offset(byte_offset); end

  sig { params(byte_offset: Integer).returns(Integer) }
  def character_column(byte_offset); end

  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
  def code_units_offset(byte_offset, encoding); end

  sig { params(encoding: Encoding).returns(T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))) }
  def code_units_cache(encoding); end

  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
  def code_units_column(byte_offset, encoding); end
end

class Prism::Location
  sig { returns(Prism::Source) }
  def source; end

  sig { returns(Integer) }
  def start_offset; end

  sig { returns(Integer) }
  def length; end

  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void }
  def initialize(source, start_offset, length); end

  sig { returns(T::Array[Prism::Comment]) }
  def leading_comments; end

  sig { params(comment: Prism::Comment).void }
  def leading_comment(comment); end

  sig { returns(T::Array[Prism::Comment]) }
  def trailing_comments; end

  sig { params(comment: Prism::Comment).void }
  def trailing_comment(comment); end

  sig { returns(T::Array[Prism::Comment]) }
  def comments; end

  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).returns(Prism::Location) }
  def copy(source: self.source, start_offset: self.start_offset, length: self.length); end

  sig { returns(Prism::Location) }
  def chop; end

  sig { returns(String) }
  def inspect; end

  sig { returns(T::Array[String]) }
  def source_lines; end

  sig { returns(String) }
  def slice; end

  sig { returns(Integer) }
  def start_character_offset; end

  sig { params(encoding: Encoding).returns(Integer) }
  def start_code_units_offset(encoding = Encoding::UTF_16LE); end

  sig { params(cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))).returns(Integer) }
  def cached_start_code_units_offset(cache); end

  sig { returns(Integer) }
  def end_offset; end

  sig { returns(Integer) }
  def end_character_offset; end

  sig { params(encoding: Encoding).returns(Integer) }
  def end_code_units_offset(encoding = Encoding::UTF_16LE); end

  sig { params(cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))).returns(Integer) }
  def cached_end_code_units_offset(cache); end

  sig { returns(Integer) }
  def start_line; end

  sig { returns(String) }
  def start_line_slice; end

  sig { returns(Integer) }
  def end_line; end

  sig { returns(Integer) }
  def start_column; end

  sig { returns(Integer) }
  def start_character_column; end

  sig { params(encoding: Encoding).returns(Integer) }
  def start_code_units_column(encoding = Encoding::UTF_16LE); end

  sig { params(cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))).returns(Integer) }
  def cached_start_code_units_column(cache); end

  sig { returns(Integer) }
  def end_column; end

  sig { returns(Integer) }
  def end_character_column; end

  sig { params(encoding: Encoding).returns(Integer) }
  def end_code_units_column(encoding = Encoding::UTF_16LE); end

  sig { params(cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))).returns(Integer) }
  def cached_end_code_units_column(cache); end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { params(q: T.untyped).void }
  def pretty_print(q); end

  sig { params(other: T.untyped).returns(T::Boolean) }
  def ==(other); end

  sig { params(other: Prism::Location).returns(Prism::Location) }
  def join(other); end

  sig { params(string: String).returns(Prism::Location) }
  def adjoin(string); end
end

class Prism::Comment
  abstract!

  sig { returns(Prism::Location) }
  def location; end

  sig { params(location: Prism::Location).void }
  def initialize(location); end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { returns(String) }
  def slice; end

  sig { abstract.returns(T::Boolean) }
  def trailing?; end
end

class Prism::InlineComment < Prism::Comment
  sig { override.returns(T::Boolean) }
  def trailing?; end

  sig { returns(String) }
  def inspect; end
end

class Prism::EmbDocComment < Prism::Comment
  sig { override.returns(T::Boolean) }
  def trailing?; end

  sig { returns(String) }
  def inspect; end
end

class Prism::MagicComment
  sig { returns(Prism::Location) }
  def key_loc; end

  sig { returns(Prism::Location) }
  def value_loc; end

  sig { params(key_loc: Prism::Location, value_loc: Prism::Location).void }
  def initialize(key_loc, value_loc); end

  sig { returns(String) }
  def key; end

  sig { returns(String) }
  def value; end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { returns(String) }
  def inspect; end
end

class Prism::ParseError
  sig { returns(Symbol) }
  def type; end

  sig { returns(String) }
  def message; end

  sig { returns(Prism::Location) }
  def location; end

  sig { returns(Symbol) }
  def level; end

  sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
  def initialize(type, message, location, level); end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { returns(String) }
  def inspect; end
end

class Prism::ParseWarning
  sig { returns(Symbol) }
  def type; end

  sig { returns(String) }
  def message; end

  sig { returns(Prism::Location) }
  def location; end

  sig { returns(Symbol) }
  def level; end

  sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
  def initialize(type, message, location, level); end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { returns(String) }
  def inspect; end
end

class Prism::Result
  sig { params(comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
  def initialize(comments, magic_comments, data_loc, errors, warnings, source); end

  sig { returns(T::Array[Prism::Comment]) }
  def comments; end

  sig { returns(T::Array[Prism::MagicComment]) }
  def magic_comments; end

  sig { returns(T.nilable(Prism::Location)) }
  def data_loc; end

  sig { returns(T::Array[Prism::ParseError]) }
  def errors; end

  sig { returns(T::Array[Prism::ParseWarning]) }
  def warnings; end

  sig { returns(Prism::Source) }
  def source; end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { returns(Encoding) }
  def encoding; end

  sig { returns(T::Boolean) }
  def success?; end

  sig { returns(T::Boolean) }
  def failure?; end

  sig { params(encoding: Encoding).returns(T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))) }
  def code_units_cache(encoding); end
end

class Prism::ParseResult < Prism::Result
  sig { params(value: Prism::ProgramNode, comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end

  sig { returns(Prism::ProgramNode) }
  def value; end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end
end

class Prism::LexResult < Prism::Result
  sig { params(value: T::Array[T.untyped], comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end

  sig { returns(T::Array[T.untyped]) }
  def value; end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end
end

class Prism::ParseLexResult < Prism::Result
  sig { params(value: [Prism::ProgramNode, T::Array[T.untyped]], comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end

  sig { returns([Prism::ProgramNode, T::Array[T.untyped]]) }
  def value; end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end
end

class Prism::Token
  sig { returns(Prism::Source) }
  def source; end

  sig { returns(Symbol) }
  def type; end

  sig { returns(String) }
  def value; end

  sig { params(source: Prism::Source, type: Symbol, value: String, location: T.any(Integer, Prism::Location)).void }
  def initialize(source, type, value, location); end

  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
  def deconstruct_keys(keys); end

  sig { returns(Prism::Location) }
  def location; end

  sig { params(q: T.untyped).void }
  def pretty_print(q); end

  sig { params(other: T.untyped).returns(T::Boolean) }
  def ==(other); end
end

class Prism::Scope
  sig { returns(T::Array[Symbol]) }
  def locals; end

  sig { returns(T::Array[Symbol]) }
  def forwarding; end

  sig { params(locals: T::Array[Symbol], forwarding: T::Array[Symbol]).void }
  def initialize(locals, forwarding); end
end