pdf-reader 2.9.2 → 2.15.0

data/rbi/pdf-reader.rbi

@@ -1,1978 +1,2002 @@
-# typed: strong
-module PDF
-  class Reader
-    sig { returns(T.untyped) }
-    attr_reader :objects
+# typed: true
 
-    sig { params(input: T.any(String, IO), opts: T::Hash[T.untyped, T.untyped]).void }
-    def initialize(input, opts = {}); end
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `pdf-reader` gem.
+# Please instead update this file by running `bundle exec spoom srb sigs export`.
 
-    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
-    def info; end
+module PDF; end
 
-    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
-    def metadata; end
+class PDF::Reader
+  sig { params(input: T.any(::IO, ::String, ::StringIO, ::Tempfile), opts: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(input, opts = T.unsafe(nil)); end
 
-    sig { returns(Integer) }
-    def page_count; end
+  sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+  def info; end
 
-    sig { returns(Float) }
-    def pdf_version; end
+  sig { returns(T.nilable(::String)) }
+  def metadata; end
 
-    sig { params(input: T.any(String, IO), opts: T::Hash[T.untyped, T.untyped], block: T.proc.params(arg0: PDF::Reader).void).returns(T.untyped) }
-    def self.open(input, opts = {}, &block); end
+  sig { returns(::PDF::Reader::ObjectHash) }
+  def objects; end
 
-    sig { returns(T::Array[PDF::Reader::Page]) }
-    def pages; end
+  sig { params(num: ::Integer).returns(::PDF::Reader::Page) }
+  def page(num); end
 
-    sig { params(num: Integer).returns(PDF::Reader::Page) }
-    def page(num); end
+  sig { returns(::Integer) }
+  def page_count; end
 
-    sig { params(obj: T.untyped).returns(T.untyped) }
-    def doc_strings_to_utf8(obj); end
+  sig { returns(T::Array[::PDF::Reader::Page]) }
+  def pages; end
 
-    sig { params(str: String).returns(T::Boolean)}
-    def has_utf16_bom?(str); end
+  sig { returns(::Float) }
+  def pdf_version; end
 
-    sig { params(obj: String).returns(String) }
-    def pdfdoc_to_utf8(obj); end
+  private
 
-    sig { params(obj: String).returns(String) }
-    def utf16_to_utf8(obj); end
+  sig { params(obj: T.untyped).returns(T.untyped) }
+  def doc_strings_to_utf8(obj); end
 
-    sig { returns(T::Hash[Symbol, T.untyped]) }
-    def root; end
+  sig { params(str: ::String).returns(T::Boolean) }
+  def has_utf16_bom?(str); end
 
-    class AesV2SecurityHandler
-      sig { params(key: String).void }
-      def initialize(key)
-        @encrypt_key = T.let(T.unsafe(nil), String)
-      end
+  sig { params(obj: ::String).returns(::String) }
+  def pdfdoc_to_utf8(obj); end
 
-      sig { params(buf: String, ref: PDF::Reader::Reference).returns(String) }
-      def decrypt(buf, ref); end
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def root; end
+
+  sig { params(obj: ::String).returns(::String) }
+  def utf16_to_utf8(obj); end
+
+  class << self
+    sig do
+      params(
+        input: T.any(::IO, ::String, ::Tempfile),
+        opts: T::Hash[T.untyped, T.untyped],
+        block: T.proc.params(arg0: ::PDF::Reader).void
+      ).returns(T.untyped)
     end
+    def open(input, opts = T.unsafe(nil), &block); end
+  end
+end
+
+class PDF::Reader::AdvancedTextRunFilter
+  sig { params(text_runs: T::Array[::PDF::Reader::TextRun], filter_hash: T::Hash[::Symbol, T.untyped]).void }
+  def initialize(text_runs, filter_hash); end
+
+  sig { returns(T::Array[::PDF::Reader::TextRun]) }
+  def exclude; end
+
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def filter_hash; end
 
-    class AesV3SecurityHandler
-      sig { params(key: String).void }
-      def initialize(key)
-        @encrypt_key = T.let(T.unsafe(nil), String)
-        @cipher = T.let(T.unsafe(nil), String)
-      end
+  sig { returns(T::Array[::PDF::Reader::TextRun]) }
+  def only; end
+
+  sig { returns(T::Array[::PDF::Reader::TextRun]) }
+  def text_runs; end
+
+  private
+
+  sig { params(attribute_value: T.untyped, operator: ::Symbol, filter_value: T.untyped).returns(T::Boolean) }
+  def apply_operator(attribute_value, operator, filter_value); end
+
+  sig do
+    params(
+      text_run: ::PDF::Reader::TextRun,
+      conditions: T::Array[T::Hash[::Symbol, T.untyped]]
+    ).returns(T::Boolean)
+  end
+  def evaluate_and_filters(text_run, conditions); end
+
+  sig do
+    params(
+      text_run: ::PDF::Reader::TextRun,
+      attribute: ::Symbol,
+      conditions: T::Hash[::Symbol, T.untyped]
+    ).returns(T::Boolean)
+  end
+  def evaluate_attribute_conditions(text_run, attribute, conditions); end
 
-      sig { params(buf: String, ref: PDF::Reader::Reference).returns(String) }
-      def decrypt(buf, ref); end
+  sig { params(text_run: ::PDF::Reader::TextRun).returns(T::Boolean) }
+  def evaluate_filter(text_run); end
+
+  sig { params(text_run: ::PDF::Reader::TextRun, filter_hash: T::Hash[::Symbol, T.untyped]).returns(T::Boolean) }
+  def evaluate_filters(text_run, filter_hash); end
+
+  sig do
+    params(
+      text_run: ::PDF::Reader::TextRun,
+      conditions: T::Array[T::Hash[::Symbol, T.untyped]]
+    ).returns(T::Boolean)
+  end
+  def evaluate_or_filters(text_run, conditions); end
+
+  class << self
+    sig do
+      params(
+        text_runs: T::Array[::PDF::Reader::TextRun],
+        filter_hash: T::Hash[::Symbol, T.untyped]
+      ).returns(T::Array[::PDF::Reader::TextRun])
     end
+    def exclude(text_runs, filter_hash); end
 
-    class BoundingRectangleRunsFilter
-      sig { params(runs: T::Array[PDF::Reader::TextRun], rect: PDF::Reader::Rectangle).returns(T::Array[PDF::Reader::TextRun]) }
-      def self.runs_within_rect(runs, rect); end
+    sig do
+      params(
+        text_runs: T::Array[::PDF::Reader::TextRun],
+        filter_hash: T::Hash[::Symbol, T.untyped]
+      ).returns(T::Array[::PDF::Reader::TextRun])
     end
+    def only(text_runs, filter_hash); end
+  end
+end
 
-    class Buffer
-      TOKEN_WHITESPACE = [0x00, 0x09, 0x0A, 0x0C, 0x0D, 0x20]
-      TOKEN_DELIMITER = [0x25, 0x3C, 0x3E, 0x28, 0x5B, 0x7B, 0x29, 0x5D, 0x7D, 0x2F]
-      LEFT_PAREN = "("
-      LESS_THAN = "<"
-      STREAM = "stream"
-      ID = "ID"
-      FWD_SLASH = "/"
-      NULL_BYTE = "\x00"
-      CR = "\r"
-      LF = "\n"
-      CRLF = "\r\n"
-      WHITE_SPACE = [LF, CR, ' ']
-      TRAILING_BYTECOUNT = 5000
+PDF::Reader::AdvancedTextRunFilter::VALID_OPERATORS = T.let(T.unsafe(nil), Array)
 
-      sig { returns(Integer) }
-      attr_reader :pos
+class PDF::Reader::AesV2SecurityHandler
+  sig { params(key: ::String).void }
+  def initialize(key); end
 
-      sig { params(io: T.any(StringIO, File), opts: T::Hash[Symbol, T.untyped]).void }
-      def initialize(io, opts = {})
-        @pos = T.let(T.unsafe(nil), Integer)
-        @tokens = T.let(T.unsafe(nil), T::Array[T.any(String, PDF::Reader::Reference)])
-        @io = T.let(T.unsafe(nil), T.any(StringIO, File))
-        @in_content_stream = T.let(T.unsafe(nil), T::Boolean)
-      end
+  sig { params(buf: ::String, ref: ::PDF::Reader::Reference).returns(::String) }
+  def decrypt(buf, ref); end
 
-      sig { returns(T::Boolean) }
-      def empty?; end
+  private
 
-      sig { params(bytes: Integer, opts: T::Hash[Symbol, T.untyped]).returns(T.nilable(String)) }
-      def read(bytes, opts = {}); end
+  sig { params(buf: ::String, ref: ::PDF::Reader::Reference, padding: T::Boolean).returns(::String) }
+  def internal_decrypt(buf, ref, padding = T.unsafe(nil)); end
+end
 
-      sig { returns(T.any(NilClass, String, PDF::Reader::Reference)) }
-      def token; end
+class PDF::Reader::AesV3SecurityHandler
+  sig { params(key: ::String).void }
+  def initialize(key); end
 
-      sig { returns(Integer) }
-      def find_first_xref_offset; end
+  sig { params(buf: ::String, ref: ::PDF::Reader::Reference).returns(::String) }
+  def decrypt(buf, ref); end
 
-      sig { void }
-      def check_size_is_non_zero; end
+  private
 
-      sig { returns(T::Boolean) }
-      def in_content_stream?; end
+  sig { params(buf: ::String, ref: ::PDF::Reader::Reference, padding: T::Boolean).returns(::String) }
+  def internal_decrypt(buf, ref, padding = T.unsafe(nil)); end
+end
 
-      sig { void }
-      def reset_pos; end
+class PDF::Reader::BoundingRectangleRunsFilter
+  class << self
+    sig do
+      params(
+        runs: T::Array[::PDF::Reader::TextRun],
+        rect: ::PDF::Reader::Rectangle
+      ).returns(T::Array[::PDF::Reader::TextRun])
+    end
+    def runs_within_rect(runs, rect); end
+  end
+end
 
-      sig { void }
-      def save_pos; end
+class PDF::Reader::Buffer
+  sig { params(io: T.any(::IO, ::StringIO, ::Tempfile), opts: T::Hash[::Symbol, T.untyped]).void }
+  def initialize(io, opts = T.unsafe(nil)); end
 
-      sig { void }
-      def prepare_tokens; end
+  sig { returns(T::Boolean) }
+  def empty?; end
 
-      sig { returns(Symbol) }
-      def state; end
+  sig { returns(::Integer) }
+  def find_first_xref_offset; end
 
-      sig { void }
-      def merge_indirect_reference; end
+  sig { returns(::Integer) }
+  def pos; end
 
-      sig { void }
-      def prepare_inline_token; end
+  sig { params(bytes: ::Integer, opts: T::Hash[::Symbol, T.untyped]).returns(T.nilable(::String)) }
+  def read(bytes, opts = T.unsafe(nil)); end
 
-      sig { void }
-      def prepare_hex_token; end
+  sig { returns(T.nilable(T.any(::PDF::Reader::Reference, ::String))) }
+  def token; end
 
-      sig { void }
-      def prepare_literal_token; end
+  private
 
-      sig { void }
-      def prepare_regular_token; end
+  sig { void }
+  def check_size_is_non_zero; end
 
-      sig { returns(T.nilable(Integer)) }
-      def peek_byte; end
-    end
+  sig { returns(T::Boolean) }
+  def in_content_stream?; end
 
-    class CidWidths
-      sig { params(default: T.untyped, array: T.untyped).void }
-      def initialize(default, array); end
+  sig { void }
+  def merge_indirect_reference; end
 
-      sig { params(default: T.untyped, array: T.untyped).returns(T.untyped) }
-      def parse_array(default, array); end
+  sig { returns(T.nilable(::Integer)) }
+  def peek_byte; end
 
-      sig { params(first: T.untyped, widths: T.untyped).returns(T.untyped) }
-      def parse_first_form(first, widths); end
+  sig { void }
+  def prepare_hex_token; end
 
-      sig { params(first: T.untyped, final: T.untyped, width: T.untyped).returns(T.untyped) }
-      def parse_second_form(first, final, width); end
-    end
+  sig { void }
+  def prepare_inline_token; end
 
-    class CMap
-      CMAP_KEYWORDS = {
-      "begincodespacerange" => 1,
-      "endcodespacerange" => 1,
-      "beginbfchar" => 1,
-      "endbfchar" => 1,
-      "beginbfrange" => 1,
-      "endbfrange" => 1,
-      "begin" => 1,
-      "begincmap" => 1,
-      "def" => 1
-    }
+  sig { void }
+  def prepare_literal_token; end
 
-      sig { returns(T.untyped) }
-      attr_reader :map
+  sig { void }
+  def prepare_regular_token; end
 
-      sig { params(data: String).void }
-      def initialize(data)
-        @map = T.let(T.unsafe(nil), T::Hash[Integer, T::Array[Integer]])
-      end
+  sig { void }
+  def prepare_tokens; end
 
-      sig { params(data: String, initial_mode: Symbol).void }
-      def process_data(data, initial_mode = :none); end
+  sig { void }
+  def reset_pos; end
 
-      sig { returns(Integer) }
-      def size; end
+  sig { void }
+  def save_pos; end
 
-      sig { params(c: Integer).returns(T::Array[Integer]) }
-      def decode(c); end
+  sig { returns(::Symbol) }
+  def state; end
+end
 
-      sig { params(instructions: String).returns(PDF::Reader::Parser) }
-      def build_parser(instructions); end
+PDF::Reader::Buffer::CR = T.let(T.unsafe(nil), String)
+PDF::Reader::Buffer::CRLF = T.let(T.unsafe(nil), String)
+PDF::Reader::Buffer::DIGITS_ONLY = T.let(T.unsafe(nil), Regexp)
+PDF::Reader::Buffer::FWD_SLASH = T.let(T.unsafe(nil), String)
+PDF::Reader::Buffer::ID = T.let(T.unsafe(nil), String)
+PDF::Reader::Buffer::LEFT_PAREN = T.let(T.unsafe(nil), String)
+PDF::Reader::Buffer::LESS_THAN = T.let(T.unsafe(nil), String)
+PDF::Reader::Buffer::LF = T.let(T.unsafe(nil), String)
+PDF::Reader::Buffer::NULL_BYTE = T.let(T.unsafe(nil), String)
+PDF::Reader::Buffer::STREAM = T.let(T.unsafe(nil), String)
+PDF::Reader::Buffer::TOKEN_DELIMITER = T.let(T.unsafe(nil), Array)
+PDF::Reader::Buffer::TOKEN_WHITESPACE = T.let(T.unsafe(nil), Array)
+PDF::Reader::Buffer::TRAILING_BYTECOUNT = T.let(T.unsafe(nil), Integer)
+PDF::Reader::Buffer::WHITE_SPACE = T.let(T.unsafe(nil), Array)
 
-      sig { params(str: String).returns(T::Array[Integer]) }
-      def str_to_int(str); end
+class PDF::Reader::CMap
+  sig { params(data: ::String).void }
+  def initialize(data); end
 
-      sig { params(instructions: T::Array[String]).void }
-      def process_bfchar_instructions(instructions); end
+  sig { params(c: ::Integer).returns(T::Array[::Integer]) }
+  def decode(c); end
 
-      sig { params(instructions: T::Array[T.any(T::Array[String], String)]).void }
-      def process_bfrange_instructions(instructions); end
+  sig { returns(T::Hash[::Integer, T::Array[::Integer]]) }
+  def map; end
 
-      sig { params(start_code: String, end_code: String, dst: String).void }
-      def bfrange_type_one(start_code, end_code, dst); end
+  sig { returns(::Integer) }
+  def size; end
 
-      sig { params(start_code: String, end_code: String, dst: T::Array[String]).void }
-      def bfrange_type_two(start_code, end_code, dst); end
-    end
+  private
 
-    class Encoding
-      CONTROL_CHARS = [0,1,2,3,4,5,6,7,8,11,12,14,15,16,17,18,19,20,21,22,23,
-                     24,25,26,27,28,29,30,31]
-      UNKNOWN_CHAR = 0x25AF
+  sig { params(start_code: ::String, end_code: ::String, dst: ::String).void }
+  def bfrange_type_one(start_code, end_code, dst); end
 
-      sig { returns(T.untyped) }
-      attr_reader :unpack
+  sig { params(start_code: ::String, end_code: ::String, dst: T::Array[::String]).void }
+  def bfrange_type_two(start_code, end_code, dst); end
 
-      sig { params(enc: T.untyped).void }
-      def initialize(enc); end
+  sig { params(instructions: ::String).returns(::PDF::Reader::Parser) }
+  def build_parser(instructions); end
 
-      sig { params(diff: T.untyped).returns(T.untyped) }
-      def differences=(diff); end
+  sig { params(instructions: T::Array[::String]).void }
+  def process_bfchar_instructions(instructions); end
 
-      sig { returns(T.untyped) }
-      def differences; end
+  sig { params(instructions: T::Array[T.any(::String, T::Array[::String])]).void }
+  def process_bfrange_instructions(instructions); end
 
-      sig { params(str: String).returns(String) }
-      def to_utf8(str); end
+  sig { params(data: ::String, initial_mode: ::Symbol).void }
+  def process_data(data, initial_mode = T.unsafe(nil)); end
 
-      sig { params(glyph_code: Integer).returns(String) }
-      def int_to_utf8_string(glyph_code); end
+  sig { params(str: ::String).returns(T::Array[::Integer]) }
+  def str_to_int(str); end
+end
 
-      sig { params(glyph_code: Integer).returns(T::Array[Symbol]) }
-      def int_to_name(glyph_code); end
+PDF::Reader::CMap::CMAP_KEYWORDS = T.let(T.unsafe(nil), Hash)
 
-      sig { returns(T.untyped) }
-      def default_mapping; end
+class PDF::Reader::CidWidths
+  extend ::Forwardable
 
-      sig { params(glyph_code: T.untyped).returns(T.untyped) }
-      def internal_int_to_utf8_string(glyph_code); end
+  sig { params(default: ::Numeric, array: T::Array[::Numeric]).void }
+  def initialize(default, array); end
 
-      sig { returns(T.untyped) }
-      def utf8_conversion_impossible?; end
+  def [](*args, **_arg1, &block); end
+  def fetch(*args, **_arg1, &block); end
 
-      sig { params(times: T.untyped).returns(T.untyped) }
-      def little_boxes(times); end
+  private
 
-      sig { params(str: T.untyped).returns(T.untyped) }
-      def convert_to_utf8(str); end
+  sig { params(default: ::Numeric, array: T::Array[::Numeric]).returns(T::Hash[::Numeric, ::Numeric]) }
+  def parse_array(default, array); end
 
-      sig { params(enc: T.untyped).returns(T.untyped) }
-      def get_unpack(enc); end
+  sig { params(first: ::Integer, widths: T::Array[::Numeric]).returns(T::Hash[::Numeric, ::Numeric]) }
+  def parse_first_form(first, widths); end
 
-      sig { params(enc: T.untyped).returns(T.untyped) }
-      def get_mapping_file(enc); end
+  sig { params(first: ::Integer, final: ::Integer, width: ::Numeric).returns(T::Hash[::Numeric, ::Numeric]) }
+  def parse_second_form(first, final, width); end
+end
 
-      sig { returns(T.untyped) }
-      def glyphlist; end
+class PDF::Reader::Encoding
+  sig { params(enc: T.nilable(T.any(::Symbol, T::Hash[::Symbol, T.untyped]))).void }
+  def initialize(enc); end
 
-      sig { params(file: T.untyped).returns(T.untyped) }
-      def load_mapping(file); end
-    end
+  sig { returns(T::Hash[::Integer, ::Integer]) }
+  def differences; end
 
-    class Error
-      sig { params(lvalue: T.untyped, rvalue: T.untyped, chars: T.untyped).returns(T.untyped) }
-      def self.str_assert(lvalue, rvalue, chars = nil); end
+  sig { params(diff: T::Array[T.any(::Integer, ::Symbol)]).returns(T::Hash[::Integer, ::Integer]) }
+  def differences=(diff); end
 
-      sig { params(lvalue: T.untyped, rvalue: T.untyped, chars: T.untyped).returns(T.untyped) }
-      def self.str_assert_not(lvalue, rvalue, chars = nil); end
+  sig { params(glyph_code: ::Integer).returns(T::Array[::Symbol]) }
+  def int_to_name(glyph_code); end
 
-      sig { params(lvalue: T.untyped, rvalue: T.untyped).returns(T.untyped) }
-      def self.assert_equal(lvalue, rvalue); end
+  sig { params(glyph_code: ::Integer).returns(::String) }
+  def int_to_utf8_string(glyph_code); end
 
-      sig { params(object: Object, name: String, klass: Module).void }
-      def self.validate_type(object, name, klass); end
+  sig { params(str: ::String).returns(::String) }
+  def to_utf8(str); end
 
-      sig { params(object: Object, name: String, klass: Module).void }
-      def self.validate_type_as_malformed(object, name, klass); end
+  sig { returns(::String) }
+  def unpack; end
 
-      sig { params(object: Object, name: String).void }
-		  def self.validate_not_nil(object, name); end
+  private
 
-      sig { params(object: Object, name: String).void }
-		  def self.validate_not_nil_as_malformed(object, name); end
-    end
+  sig { params(str: ::String).returns(::String) }
+  def convert_to_utf8(str); end
 
-    class MalformedPDFError < RuntimeError
-    end
+  sig { returns(T::Hash[::Integer, ::Integer]) }
+  def default_mapping; end
 
-    class InvalidPageError < ArgumentError
-    end
+  sig { params(enc: ::Symbol).returns(T.nilable(::String)) }
+  def get_mapping_file(enc); end
 
-    class InvalidObjectError < MalformedPDFError
-    end
+  sig { params(enc: ::Symbol).returns(::String) }
+  def get_unpack(enc); end
 
-    class UnsupportedFeatureError < RuntimeError
-    end
+  sig { returns(::PDF::Reader::GlyphHash) }
+  def glyphlist; end
 
-    class EncryptedPDFError < UnsupportedFeatureError
-    end
+  sig { params(glyph_code: ::Integer).returns(::String) }
+  def internal_int_to_utf8_string(glyph_code); end
 
-    class Font
-      sig { returns(T.untyped) }
-      attr_accessor :subtype
+  sig { params(times: ::Integer).returns(::String) }
+  def little_boxes(times); end
 
-      sig { returns(T.untyped) }
-      attr_accessor :encoding
+  sig { params(file: ::String).void }
+  def load_mapping(file); end
 
-      sig { returns(T.untyped) }
-      attr_accessor :descendantfonts
+  sig { returns(T::Boolean) }
+  def utf8_conversion_impossible?; end
+end
 
-      sig { returns(T.untyped) }
-      attr_accessor :tounicode
+PDF::Reader::Encoding::CONTROL_CHARS = T.let(T.unsafe(nil), Array)
+PDF::Reader::Encoding::UNKNOWN_CHAR = T.let(T.unsafe(nil), Integer)
+class PDF::Reader::EncryptedPDFError < ::PDF::Reader::UnsupportedFeatureError; end
 
-      sig { returns(T.untyped) }
-      attr_reader :widths
+class PDF::Reader::Error
+  class << self
+    sig { params(lvalue: T.untyped, rvalue: T.untyped).returns(T.untyped) }
+    def assert_equal(lvalue, rvalue); end
 
-      sig { returns(T.untyped) }
-      attr_reader :first_char
+    sig { params(lvalue: T.untyped, rvalue: T.untyped, chars: T.untyped).returns(T.untyped) }
+    def str_assert(lvalue, rvalue, chars = T.unsafe(nil)); end
 
-      sig { returns(T.untyped) }
-      attr_reader :last_char
+    sig { params(lvalue: T.untyped, rvalue: T.untyped, chars: T.untyped).returns(T.untyped) }
+    def str_assert_not(lvalue, rvalue, chars = T.unsafe(nil)); end
 
-      sig { returns(T.untyped) }
-      attr_reader :basefont
+    sig { params(object: ::Object, name: ::String).void }
+    def validate_not_nil(object, name); end
 
-      sig { returns(T.untyped) }
-      attr_reader :font_descriptor
+    sig { params(object: ::Object, name: ::String, klass: ::Module).void }
+    def validate_type(object, name, klass); end
 
-      sig { returns(T.untyped) }
-      attr_reader :cid_widths
+    sig { params(object: ::Object, name: ::String, klass: ::Module).void }
+    def validate_type_as_malformed(object, name, klass); end
+  end
+end
 
-      sig { returns(T.untyped) }
-      attr_reader :cid_default_width
+class PDF::Reader::EventPoint
+  sig { params(x: ::Numeric, run: ::PDF::Reader::TextRun).void }
+  def initialize(x, run); end
 
-      sig { params(ohash: T.untyped, obj: T.untyped).void }
-      def initialize(ohash, obj); end
+  sig { returns(::PDF::Reader::TextRun) }
+  def run; end
 
-      sig { params(params: T.untyped).returns(T.untyped) }
-      def to_utf8(params); end
+  sig { returns(T::Boolean) }
+  def start?; end
 
-      sig { params(data: T.untyped).returns(T.untyped) }
-      def unpack(data); end
+  sig { returns(::Numeric) }
+  def x; end
+end
 
-      sig { params(code_point: T.untyped).returns(T.untyped) }
-      def glyph_width(code_point); end
+module PDF::Reader::Filter
+  class << self
+    sig { params(name: ::Symbol, options: T::Hash[T.untyped, T.untyped]).returns(T.untyped) }
+    def with(name, options = T.unsafe(nil)); end
+  end
+end
 
-      sig { params(font_name: T.untyped).returns(T.untyped) }
-      def default_encoding(font_name); end
+class PDF::Reader::Filter::Ascii85
+  sig { params(options: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(options = T.unsafe(nil)); end
 
-      sig { returns(T.untyped) }
-      def build_width_calculator; end
+  sig { params(data: ::String).returns(::String) }
+  def filter(data); end
+end
 
-      sig { params(obj: T.untyped).returns(T.untyped) }
-      def extract_base_info(obj); end
+class PDF::Reader::Filter::AsciiHex
+  sig { params(options: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(options = T.unsafe(nil)); end
 
-      sig { params(obj: T.untyped).returns(T.untyped) }
-      def extract_descriptor(obj); end
+  sig { params(data: ::String).returns(::String) }
+  def filter(data); end
+end
 
-      sig { params(obj: T.untyped).returns(T.untyped) }
-      def extract_descendants(obj); end
+class PDF::Reader::Filter::Depredict
+  sig { params(options: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(options = T.unsafe(nil)); end
 
-      sig { params(params: T.untyped).returns(T.untyped) }
-      def to_utf8_via_cmap(params); end
+  sig { params(data: ::String).returns(::String) }
+  def filter(data); end
 
-      sig { params(params: T.untyped).returns(T.untyped) }
-      def to_utf8_via_encoding(params); end
-    end
+  private
 
-    class FontDescriptor
-      sig { returns(T.untyped) }
-      attr_reader :font_name
+  sig { params(data: T.untyped).returns(::String) }
+  def png_depredict(data); end
 
-      sig { returns(T.untyped) }
-      attr_reader :font_family
+  sig { params(data: T.untyped).returns(::String) }
+  def tiff_depredict(data); end
+end
 
-      sig { returns(T.untyped) }
-      attr_reader :font_stretch
+class PDF::Reader::Filter::Flate
+  sig { params(options: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(options = T.unsafe(nil)); end
 
-      sig { returns(T.untyped) }
-      attr_reader :font_weight
+  sig { params(data: ::String).returns(::String) }
+  def filter(data); end
 
-      sig { returns(T.untyped) }
-      attr_reader :font_bounding_box
+  private
 
-      sig { returns(T.untyped) }
-      attr_reader :cap_height
+  sig { params(data: T.untyped).returns(T.untyped) }
+  def zlib_inflate(data); end
+end
 
-      sig { returns(T.untyped) }
-      attr_reader :ascent
+PDF::Reader::Filter::Flate::ZLIB_AUTO_DETECT_ZLIB_OR_GZIP = T.let(T.unsafe(nil), Integer)
+PDF::Reader::Filter::Flate::ZLIB_RAW_DEFLATE = T.let(T.unsafe(nil), Integer)
 
-      sig { returns(T.untyped) }
-      attr_reader :descent
+class PDF::Reader::Filter::Lzw
+  sig { params(options: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(options = T.unsafe(nil)); end
 
-      sig { returns(T.untyped) }
-      attr_reader :leading
+  sig { params(data: ::String).returns(::String) }
+  def filter(data); end
+end
 
-      sig { returns(T.untyped) }
-      attr_reader :avg_width
+class PDF::Reader::Filter::Null
+  sig { params(options: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(options = T.unsafe(nil)); end
 
-      sig { returns(T.untyped) }
-      attr_reader :max_width
+  sig { params(data: ::String).returns(::String) }
+  def filter(data); end
+end
 
-      sig { returns(T.untyped) }
-      attr_reader :missing_width
+class PDF::Reader::Filter::RunLength
+  sig { params(options: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(options = T.unsafe(nil)); end
 
-      sig { returns(T.untyped) }
-      attr_reader :italic_angle
+  sig { params(data: ::String).returns(::String) }
+  def filter(data); end
+end
 
-      sig { returns(T.untyped) }
-      attr_reader :stem_v
+class PDF::Reader::Font
+  sig { params(ohash: ::PDF::Reader::ObjectHash, obj: T::Hash[::Symbol, T.untyped]).void }
+  def initialize(ohash, obj); end
 
-      sig { returns(T.untyped) }
-      attr_reader :x_height
+  sig { returns(T.nilable(::Symbol)) }
+  def basefont; end
 
-      sig { returns(T.untyped) }
-      attr_reader :font_flags
+  sig { returns(::Numeric) }
+  def cid_default_width; end
 
-      sig { params(ohash: PDF::Reader::ObjectHash, fd_hash: T::Hash[T.untyped, T.untyped]).void }
-      def initialize(ohash, fd_hash); end
+  sig { returns(T::Array[::Numeric]) }
+  def cid_widths; end
 
-      sig { params(char_code: T.untyped).returns(T.untyped) }
-      def glyph_width(char_code); end
+  sig { returns(T::Array[::PDF::Reader::Font]) }
+  def descendantfonts; end
 
-      sig { returns(T.untyped) }
-      def glyph_to_pdf_scale_factor; end
+  def descendantfonts=(_arg0); end
 
-      sig { returns(T.untyped) }
-      def ttf_program_stream; end
-    end
+  sig { returns(::PDF::Reader::Encoding) }
+  def encoding; end
 
-    class FormXObject
-      include ResourceMethods
+  def encoding=(_arg0); end
 
-      sig { returns(T.untyped) }
-      attr_reader :xobject
+  sig { returns(T.nilable(::Integer)) }
+  def first_char; end
 
-      sig { params(page: T.untyped, xobject: T.untyped, options: T.untyped).void }
-      def initialize(page, xobject, options = {}); end
+  sig { returns(T.nilable(::PDF::Reader::FontDescriptor)) }
+  def font_descriptor; end
 
-      sig { returns(T.untyped) }
-      def font_objects; end
+  sig { params(code_point: T.any(::Integer, ::String)).returns(::Numeric) }
+  def glyph_width(code_point); end
 
-      sig { params(receivers: T.untyped).returns(T.untyped) }
-      def walk(*receivers); end
+  sig { params(code_point: T.any(::Integer, ::String)).returns(::Numeric) }
+  def glyph_width_in_text_space(code_point); end
 
-      sig { returns(T.untyped) }
-      def raw_content; end
+  sig { returns(T.nilable(::Integer)) }
+  def last_char; end
 
-      sig { returns(T.untyped) }
-      def resources; end
+  sig { returns(T.nilable(::Symbol)) }
+  def subtype; end
 
-      sig { params(receivers: T.untyped, name: T.untyped, params: T.untyped).returns(T.untyped) }
-      def callback(receivers, name, params = []); end
+  def subtype=(_arg0); end
 
-      sig { returns(T.untyped) }
-      def content_stream_md5; end
+  sig { params(params: T.any(::Integer, ::String, T::Array[T.any(::Integer, ::String)])).returns(::String) }
+  def to_utf8(params); end
 
-      sig { returns(T.untyped) }
-      def cached_tokens_key; end
+  sig { returns(T.nilable(::PDF::Reader::CMap)) }
+  def tounicode; end
 
-      sig { returns(T.untyped) }
-      def tokens; end
+  def tounicode=(_arg0); end
 
-      sig { params(receivers: T.untyped, instructions: T.untyped).returns(T.untyped) }
-      def content_stream(receivers, instructions); end
-    end
+  sig { params(data: ::String).returns(T.nilable(T::Array[T.nilable(T.any(::Float, ::Integer, ::String))])) }
+  def unpack(data); end
 
-    class GlyphHash
-      sig { void }
-      def initialize; end
+  sig { returns(T::Array[::Numeric]) }
+  def widths; end
 
-      sig { params(name: T.untyped).returns(T.untyped) }
-      def name_to_unicode(name); end
+  private
 
-      sig { params(codepoint: T.untyped).returns(T.untyped) }
-      def unicode_to_name(codepoint); end
+  sig { params(obj: T::Hash[::Symbol, T.untyped]).returns(::PDF::Reader::Encoding) }
+  def build_encoding(obj); end
 
-      sig { returns(T.untyped) }
-      def load_adobe_glyph_mapping; end
-    end
+  sig { returns(T.untyped) }
+  def build_width_calculator; end
 
-    class KeyBuilderV5
-      sig { params(opts: T::Hash[Symbol, String]).void }
-      def initialize(opts = {})
-        @key_length = T.let(T.unsafe(nil), Integer)
-        @owner_key = T.let(T.unsafe(nil), String)
-        @user_key = T.let(T.unsafe(nil), String)
-        @owner_encryption_key = T.let(T.unsafe(nil), String)
-        @user_encryption_key = T.let(T.unsafe(nil), String)
-      end
+  sig { params(font_name: T.nilable(T.any(::String, ::Symbol))).returns(::PDF::Reader::Encoding) }
+  def default_encoding(font_name); end
 
-      sig { params(pass: String).returns(String) }
-      def key(pass); end
+  sig { params(obj: T::Hash[::Symbol, T.untyped]).void }
+  def extract_base_info(obj); end
 
-      sig { params(password: T.untyped).returns(T.untyped) }
-      def auth_owner_pass(password); end
+  sig { params(obj: T::Hash[::Symbol, T.untyped]).void }
+  def extract_descendants(obj); end
 
-      sig { params(password: T.untyped).returns(T.untyped) }
-      def auth_user_pass(password); end
+  sig { params(obj: T::Hash[::Symbol, T.untyped]).void }
+  def extract_descriptor(obj); end
 
-      sig { params(password: String).returns(T.nilable(String)) }
-      def auth_owner_pass_r6(password); end
+  sig { params(obj: T::Hash[::Symbol, T.untyped]).void }
+  def extract_type3_info(obj); end
 
-      sig { params(password: String).returns(T.nilable(String)) }
-      def auth_user_pass_r6(password); end
+  sig { params(x: ::Numeric, y: ::Numeric).returns([::Numeric, ::Numeric]) }
+  def font_matrix_transform(x, y); end
 
-      sig { params(password: String, salt: String, user_key: String).returns(String)}
-      def r6_digest(password, salt, user_key = ''); end
+  sig do
+    params(
+      params: T.any(::Integer, ::String, T::Array[T.any(::Integer, ::String)]),
+      cmap: ::PDF::Reader::CMap
+    ).returns(::String)
+  end
+  def to_utf8_via_cmap(params, cmap); end
 
-      sig { params(str: String).returns(Integer)}
-      def unpack_128bit_bigendian_int(str); end
-    end
+  sig { params(params: T.any(::Integer, ::String, T::Array[T.any(::Integer, ::String)])).returns(::String) }
+  def to_utf8_via_encoding(params); end
 
-    class LZW
-      CODE_EOD = 257
-      CODE_CLEAR_TABLE = 256
+  sig { params(unpack_me: ::String, unpack_arg: ::String).returns(T::Array[::Integer]) }
+  def unpack_string_to_array_of_ints(unpack_me, unpack_arg); end
+end
 
-      class BitStream
-        sig { params(data: T.untyped, bits_in_chunk: T.untyped).void }
-        def initialize(data, bits_in_chunk); end
+class PDF::Reader::FontDescriptor
+  sig { params(ohash: ::PDF::Reader::ObjectHash, fd_hash: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(ohash, fd_hash); end
 
-        sig { params(bits_in_chunk: T.untyped).returns(T.untyped) }
-        def set_bits_in_chunk(bits_in_chunk); end
+  sig { returns(::Numeric) }
+  def ascent; end
 
-        sig { returns(T.untyped) }
-        def read; end
-      end
+  sig { returns(::Numeric) }
+  def avg_width; end
 
-      class StringTable < Hash
-        sig { returns(T.untyped) }
-        attr_reader :string_table_pos
+  sig { returns(::Numeric) }
+  def cap_height; end
 
-        sig { void }
-        def initialize; end
+  sig { returns(::Numeric) }
+  def descent; end
 
-        sig { params(key: T.untyped).returns(T.untyped) }
-        def [](key); end
+  sig { returns(T::Array[::Numeric]) }
+  def font_bounding_box; end
 
-        sig { params(string: T.untyped).returns(T.untyped) }
-        def add(string); end
-      end
+  sig { returns(T.nilable(::String)) }
+  def font_family; end
 
-      sig { params(data: T.untyped).returns(T.untyped) }
-      def self.decode(data); end
+  sig { returns(::Integer) }
+  def font_flags; end
 
-      sig { params(string_table: T.untyped, some_code: T.untyped, other_code: T.untyped).returns(T.untyped) }
-      def self.create_new_string(string_table, some_code, other_code); end
-    end
+  sig { returns(::String) }
+  def font_name; end
 
-    class NullSecurityHandler
-      sig { params(buf: T.untyped, _ref: T.untyped).returns(T.untyped) }
-      def decrypt(buf, _ref); end
-    end
+  sig { returns(::Symbol) }
+  def font_stretch; end
 
-    class ObjectCache
-      CACHEABLE_TYPES = [:Catalog, :Page, :Pages]
+  sig { returns(::Numeric) }
+  def font_weight; end
 
-      sig { returns(T.untyped) }
-      attr_reader :hits
+  sig { returns(::Numeric) }
+  def glyph_to_pdf_scale_factor; end
 
-      sig { returns(T.untyped) }
-      attr_reader :misses
+  sig { params(char_code: ::Integer).returns(::Numeric) }
+  def glyph_width(char_code); end
 
-      sig { params(lru_size: T.untyped).void }
-      def initialize(lru_size = 1000); end
+  sig { returns(T.nilable(::Numeric)) }
+  def italic_angle; end
 
-      sig { params(key: T.untyped).returns(T.untyped) }
-      def [](key); end
+  sig { returns(::Numeric) }
+  def leading; end
 
-      sig { params(key: T.untyped, value: T.untyped).returns(T.untyped) }
-      def []=(key, value); end
+  sig { returns(::Numeric) }
+  def max_width; end
 
-      sig { params(key: T.untyped, local_default: T.untyped).returns(T.untyped) }
-      def fetch(key, local_default = nil); end
+  sig { returns(::Numeric) }
+  def missing_width; end
 
-      sig { params(block: T.untyped).returns(T.untyped) }
-      def each(&block); end
+  sig { returns(T.nilable(::Numeric)) }
+  def stem_v; end
 
-      sig { params(block: T.untyped).returns(T.untyped) }
-      def each_key(&block); end
+  sig { returns(T.nilable(::Numeric)) }
+  def x_height; end
 
-      sig { params(block: T.untyped).returns(T.untyped) }
-      def each_value(&block); end
+  private
 
-      sig { returns(T.untyped) }
-      def size; end
+  sig { returns(::TTFunk::File) }
+  def ttf_program_stream; end
+end
 
-      sig { returns(T.untyped) }
-      def empty?; end
+class PDF::Reader::FormXObject
+  extend ::Forwardable
 
-      sig { params(key: T.untyped).returns(T.untyped) }
-      def include?(key); end
+  sig { params(page: T.untyped, xobject: T.untyped, options: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(page, xobject, options = T.unsafe(nil)); end
 
-      sig { params(value: T.untyped).returns(T.untyped) }
-      def has_value?(value); end
+  def color_spaces(*args, **_arg1, &block); end
 
-      sig { returns(T.untyped) }
-      def to_s; end
+  sig { returns(T.untyped) }
+  def font_objects; end
 
-      sig { returns(T.untyped) }
-      def keys; end
+  def fonts(*args, **_arg1, &block); end
+  def graphic_states(*args, **_arg1, &block); end
+  def patterns(*args, **_arg1, &block); end
+  def procedure_sets(*args, **_arg1, &block); end
+  def properties(*args, **_arg1, &block); end
 
-      sig { returns(T.untyped) }
-      def values; end
+  sig { returns(T.untyped) }
+  def raw_content; end
 
-      sig { params(key: T.untyped).returns(T.untyped) }
-      def update_stats(key); end
+  def shadings(*args, **_arg1, &block); end
 
-      sig { params(obj: T.untyped).returns(T.untyped) }
-      def cacheable?(obj); end
-    end
+  sig { params(receivers: T.untyped).returns(T.untyped) }
+  def walk(*receivers); end
+
+  sig { returns(T.untyped) }
+  def xobject; end
 
-    class ObjectHash
-      include Enumerable
+  def xobjects(*args, **_arg1, &block); end
 
-      sig { returns(T.untyped) }
-      attr_accessor :default
+  private
 
-      sig { returns(T.untyped) }
-      attr_reader :trailer
+  sig { returns(T.untyped) }
+  def cached_tokens_key; end
 
-      sig { returns(T.untyped) }
-      attr_reader :pdf_version
+  sig { params(receivers: T.untyped, name: T.untyped, params: T::Array[T.untyped]).returns(T.untyped) }
+  def callback(receivers, name, params = T.unsafe(nil)); end
 
-      sig { returns(T.untyped) }
-      attr_reader :sec_handler
+  sig { params(receivers: T.untyped, instructions: T.untyped).returns(T.untyped) }
+  def content_stream(receivers, instructions); end
 
-      sig { params(input: T.untyped, opts: T.untyped).void }
-      def initialize(input, opts = {}); end
+  sig { returns(T.untyped) }
+  def content_stream_md5; end
 
-      sig { params(ref: T.untyped).returns(T.untyped) }
-      def obj_type(ref); end
+  sig { returns(T.untyped) }
+  def resources; end
 
-      sig { params(ref: T.untyped).returns(T.untyped) }
-      def stream?(ref); end
+  sig { returns(T.untyped) }
+  def tokens; end
+end
+
+class PDF::Reader::GlyphHash
+  sig { void }
+  def initialize; end
+
+  sig { params(name: T.nilable(::Symbol)).returns(T.nilable(::Integer)) }
+  def name_to_unicode(name); end
 
-      sig { params(key: T.untyped).returns(T.untyped) }
-      def [](key); end
+  sig { params(codepoint: ::Integer).returns(T::Array[::Symbol]) }
+  def unicode_to_name(codepoint); end
 
-      sig { params(key: T.untyped).returns(T.untyped) }
-      def object(key); end
+  private
 
-      sig { params(key: T.untyped).returns(T.nilable(T::Array[T.untyped])) }
-      def deref_array(key); end
+  sig { returns(::PDF::Reader::GlyphHash::ReturnData) }
+  def load_adobe_glyph_mapping; end
+end
+
+class PDF::Reader::GlyphHash::ReturnData
+  def initialize(by_name, by_codepoint); end
 
-      sig { params(key: T.untyped).returns(T.nilable(T::Array[Numeric])) }
-      def deref_array_of_numbers(key); end
+  sig { returns(T::Hash[::Integer, T::Array[::Symbol]]) }
+  def by_codepoint; end
 
-      sig { params(key: T.untyped).returns(T.nilable(T:Hash[Symbol, T.untyped])) }
-      def deref_hash(key); end
+  sig { returns(T::Hash[::Symbol, ::Integer]) }
+  def by_name; end
+end
 
-      sig { params(key: T.untyped).returns(T.nilable(Symbol)) }
-      def deref_name(key); end
+class PDF::Reader::InvalidObjectError < ::PDF::Reader::MalformedPDFError; end
+class PDF::Reader::InvalidPageError < ::ArgumentError; end
 
-      sig { params(key: T.untyped).returns(T.any(Symbol, T::Array[T.untyped], NilClass)) }
-      def deref_name_or_array(key); end
+class PDF::Reader::KeyBuilderV5
+  sig { params(opts: T::Hash[::Symbol, ::String]).void }
+  def initialize(opts = T.unsafe(nil)); end
 
-      sig { params(key: T.untyped).returns(T.nilable(Integer)) }
-      def deref_integer(key); end
+  sig { params(pass: ::String).returns(::String) }
+  def key(pass); end
 
-      sig { params(key: T.untyped).returns(T.nilable(Numeric)) }
-      def deref_number(key); end
+  private
 
-      sig { params(key: T.untyped).returns(T.nilable(PDF::Reader::Stream)) }
-      def deref_stream(key); end
+  sig { params(password: ::String).returns(T.nilable(::String)) }
+  def auth_owner_pass(password); end
 
-      sig { params(key: T.untyped).returns(T.nilable(String)) }
-      def deref_string(key); end
+  sig { params(password: ::String).returns(T.nilable(::String)) }
+  def auth_owner_pass_r6(password); end
 
-      sig { params(key: T.untyped).returns(T.any(PDF::Reader::Stream, T::Array[T.untyped], NilClass)) }
-      def deref_stream_or_array(key); end
+  sig { params(password: ::String).returns(T.nilable(::String)) }
+  def auth_user_pass(password); end
 
-      sig { params(key: T.untyped).returns(T.untyped) }
-      def deref!(key); end
+  sig { params(password: ::String).returns(T.nilable(::String)) }
+  def auth_user_pass_r6(password); end
 
-      sig { params(key: T.untyped).returns(T::Array[T.untyped]) }
-      def deref_array!(key); end
+  sig { params(password: ::String, salt: ::String, user_key: ::String).returns(::String) }
+  def r6_digest(password, salt, user_key = T.unsafe(nil)); end
 
-      sig { params(key: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
-      def deref_hash!(key); end
+  sig { params(str: ::String).returns(::Integer) }
+  def unpack_128bit_bigendian_int(str); end
+end
 
-      sig { params(key: T.untyped, local_default: T.untyped).returns(T.untyped) }
-      def fetch(key, local_default = nil); end
+class PDF::Reader::LZW
+  class << self
+    sig { params(data: ::String).returns(::String) }
+    def decode(data); end
 
-      sig { params(block: T.untyped).returns(T.untyped) }
-      def each(&block); end
+    private
 
-      sig { params(block: T.untyped).returns(T.untyped) }
-      def each_key(&block); end
+    sig do
+      params(
+        string_table: ::PDF::Reader::LZW::StringTable,
+        some_code: T.nilable(::Integer),
+        other_code: T.nilable(::Integer)
+      ).returns(::String)
+    end
+    def create_new_string(string_table, some_code, other_code); end
+  end
+end
 
-      sig { params(block: T.untyped).returns(T.untyped) }
-      def each_value(&block); end
+class PDF::Reader::LZW::BitStream
+  sig { params(data: ::String, bits_in_chunk: ::Integer).void }
+  def initialize(data, bits_in_chunk); end
 
-      sig { returns(Integer) }
-      def size; end
+  sig { returns(::Integer) }
+  def read; end
 
-      sig { returns(T::Boolean) }
-      def empty?; end
+  sig { params(bits_in_chunk: ::Integer).void }
+  def set_bits_in_chunk(bits_in_chunk); end
+end
 
-      sig { params(check_key: T.untyped).returns(T::Boolean) }
-      def has_key?(check_key); end
+PDF::Reader::LZW::CODE_CLEAR_TABLE = T.let(T.unsafe(nil), Integer)
+PDF::Reader::LZW::CODE_EOD = T.let(T.unsafe(nil), Integer)
 
-      sig { params(value: T.untyped).returns(T::Boolean) }
-      def has_value?(value); end
+class PDF::Reader::LZW::StringTable
+  sig { void }
+  def initialize; end
 
-      sig { returns(String) }
-      def to_s; end
+  sig { params(key: ::Integer).returns(T.nilable(::String)) }
+  def [](key); end
 
-      sig { returns(T::Array[PDF::Reader::Reference]) }
-      def keys; end
+  sig { params(string: ::String).void }
+  def add(string); end
 
-      sig { returns(T.untyped) }
-      def values; end
+  sig { returns(::Integer) }
+  def string_table_pos; end
+end
 
-      sig { params(ids: T.untyped).returns(T.untyped) }
-      def values_at(*ids); end
+class PDF::Reader::MalformedPDFError < ::RuntimeError; end
 
-      sig { returns(T.untyped) }
-      def to_a; end
+class PDF::Reader::NoTextFilter
+  class << self
+    sig { params(runs: T::Array[::PDF::Reader::TextRun]).returns(T::Array[::PDF::Reader::TextRun]) }
+    def exclude_empty_strings(runs); end
+  end
+end
 
-      sig { returns(T::Array[PDF::Reader::Reference]) }
-      def page_references; end
+class PDF::Reader::NullSecurityHandler
+  sig { params(buf: ::String, _ref: ::PDF::Reader::Reference).returns(::String) }
+  def decrypt(buf, _ref); end
+end
 
-      sig { returns(T::Boolean) }
-      def encrypted?; end
+class PDF::Reader::ObjectCache
+  sig { params(lru_size: T.untyped).void }
+  def initialize(lru_size = T.unsafe(nil)); end
+
+  def [](key); end
+  def []=(key, value); end
+  def each(&block); end
+  def each_key(&block); end
+  def each_pair(&block); end
+  def each_value(&block); end
+  def empty?; end
+  def fetch(key, local_default = T.unsafe(nil)); end
+  def has_key?(key); end
+  def has_value?(value); end
+
+  sig { returns(T.untyped) }
+  def hits; end
+
+  def include?(key); end
+  def key?(key); end
+  def keys; end
+  def length; end
+  def member?(key); end
+
+  sig { returns(T.untyped) }
+  def misses; end
+
+  def size; end
+  def to_s; end
+  def values; end
+
+  private
+
+  def cacheable?(obj); end
+  def update_stats(key); end
+end
 
-      sig { returns(T::Boolean) }
-      def sec_handler?; end
+PDF::Reader::ObjectCache::CACHEABLE_TYPES = T.let(T.unsafe(nil), Array)
 
-      sig { params(key: T.untyped).returns(T.untyped) }
-      def fetch_object(key); end
+class PDF::Reader::ObjectHash
+  include ::Enumerable
 
-      sig { params(key: T.untyped).returns(T.untyped) }
-      def fetch_object_stream(key); end
+  sig { params(input: T.any(::IO, ::String, ::StringIO, ::Tempfile), opts: T::Hash[::Symbol, T.untyped]).void }
+  def initialize(input, opts = T.unsafe(nil)); end
 
-      sig { params(key: T.untyped, seen: T.untyped).returns(T.untyped) }
-      def deref_internal!(key, seen); end
+  sig { params(key: T.any(::Integer, ::PDF::Reader::Reference)).returns(T.untyped) }
+  def [](key); end
 
-      sig { params(ref: T.untyped, obj: T.untyped).returns(T.untyped) }
-      def decrypt(ref, obj); end
+  sig { returns(T.untyped) }
+  def default; end
 
-      sig { params(offset: Integer).returns(PDF::Reader::Buffer) }
-      def new_buffer(offset = 0); end
+  def default=(_arg0); end
+  def deref(*args, **_arg1, &blk); end
 
-      sig { returns(T.untyped) }
-      def xref; end
+  sig { params(key: T.untyped).returns(T.untyped) }
+  def deref!(key); end
 
-      sig { returns(T.untyped) }
-      def object_streams; end
+  sig { params(key: T.untyped).returns(T.nilable(T::Array[T.untyped])) }
+  def deref_array(key); end
 
-      sig { params(obj: T::Hash[T.untyped, T.untyped]).returns(T::Array[T::Hash[T.untyped, T.untyped]]) }
-      def get_page_objects(obj); end
+  sig { params(key: T.untyped).returns(T.nilable(T::Array[T.untyped])) }
+  def deref_array!(key); end
 
-      sig { returns(Float) }
-      def read_version; end
+  sig { params(key: T.untyped).returns(T.nilable(T::Array[::Numeric])) }
+  def deref_array_of_numbers(key); end
 
-      sig { params(input: T.untyped).returns(IO) }
-      def extract_io_from(input); end
+  sig { params(key: T.untyped).returns(T.nilable(T::Hash[::Symbol, T.untyped])) }
+  def deref_hash(key); end
 
-      sig { params(input: T.untyped).returns(T.untyped) }
-      def read_as_binary(input); end
-    end
+  sig { params(key: T.untyped).returns(T.nilable(T::Hash[::Symbol, T.untyped])) }
+  def deref_hash!(key); end
 
-    class ObjectStream
-      sig { params(stream: T.untyped).void }
-      def initialize(stream); end
+  sig { params(key: T.untyped).returns(T.nilable(::Integer)) }
+  def deref_integer(key); end
 
-      sig { params(objid: T.untyped).returns(T.untyped) }
-      def [](objid); end
+  sig { params(key: T.untyped).returns(T.nilable(::Symbol)) }
+  def deref_name(key); end
 
-      sig { returns(T.untyped) }
-      def size; end
+  sig { params(key: T.untyped).returns(T.nilable(T.any(::Symbol, T::Array[T.untyped]))) }
+  def deref_name_or_array(key); end
 
-      sig { returns(T.untyped) }
-      def offsets; end
+  sig { params(key: T.untyped).returns(T.nilable(::Numeric)) }
+  def deref_number(key); end
 
-      sig { returns(T.untyped) }
-      def first; end
+  sig { params(key: T.untyped).returns(T.nilable(::PDF::Reader::Stream)) }
+  def deref_stream(key); end
 
-      sig { returns(T.untyped) }
-      def buffer; end
-    end
+  sig { params(key: T.untyped).returns(T.nilable(T.any(::PDF::Reader::Stream, T::Array[T.untyped]))) }
+  def deref_stream_or_array(key); end
 
-    class OverlappingRunsFilter
-      OVERLAPPING_THRESHOLD = 0.5
+  sig { params(key: T.untyped).returns(T.nilable(::String)) }
+  def deref_string(key); end
 
-      sig { params(runs: T::Array[PDF::Reader::TextRun]).returns(T::Array[PDF::Reader::TextRun]) }
-      def self.exclude_redundant_runs(runs); end
+  sig do
+    override
+      .params(
+        block: T.proc.params(arg0: ::PDF::Reader::Reference, arg1: T.untyped).returns(T.untyped)
+      ).returns(T.untyped)
+  end
+  def each(&block); end
 
-      sig { params(sweep_line_status: T::Array[PDF::Reader::TextRun], event_point: EventPoint).returns(T::Boolean) }
-      def self.detect_intersection(sweep_line_status, event_point); end
-    end
+  sig { params(block: T.proc.params(arg0: ::PDF::Reader::Reference).returns(T.untyped)).returns(T.untyped) }
+  def each_key(&block); end
 
-    class EventPoint
-      sig { returns(Numeric) }
-      attr_reader :x
+  def each_pair(*args, **_arg1, &blk); end
 
-      sig { returns(PDF::Reader::TextRun) }
-      attr_reader :run
+  sig { params(block: T.proc.params(arg0: T.untyped).returns(T.untyped)).returns(T.untyped) }
+  def each_value(&block); end
 
-      sig { params(x: Numeric, run: PDF::Reader::TextRun).void }
-      def initialize(x, run); end
+  sig { returns(T::Boolean) }
+  def empty?; end
 
-      sig { returns(T::Boolean) }
-      def start?; end
-    end
+  sig { returns(T::Boolean) }
+  def encrypted?; end
 
-    class Page
-      include ResourceMethods
+  sig { params(key: T.untyped, local_default: T.untyped).returns(T.untyped) }
+  def fetch(key, local_default = T.unsafe(nil)); end
 
-      sig { returns(PDF::Reader::ObjectHash) }
-      attr_reader :objects
+  sig { params(check_key: T.untyped).returns(T::Boolean) }
+  def has_key?(check_key); end
 
-      sig { returns(T.untyped) }
-      attr_reader :page_object
+  sig { params(value: T.untyped).returns(T::Boolean) }
+  def has_value?(value); end
 
-      sig { returns(T.untyped) }
-      attr_reader :cache
+  def include?(*args, **_arg1, &blk); end
+  def key?(*args, **_arg1, &blk); end
 
-      sig { params(objects: PDF::Reader::ObjectHash, pagenum: Integer, options: T::Hash[Symbol, T.untyped]).void }
-      def initialize(objects, pagenum, options = {}); end
+  sig { returns(T::Array[::PDF::Reader::Reference]) }
+  def keys; end
 
-      sig { returns(Integer) }
-      def number; end
+  def length(*args, **_arg1, &blk); end
+  def member?(*args, **_arg1, &blk); end
 
-      sig { returns(String) }
-      def inspect; end
+  sig { params(ref: T.any(::Integer, ::PDF::Reader::Reference)).returns(T.nilable(::Symbol)) }
+  def obj_type(ref); end
 
-      sig { returns(T::Hash[Symbol, T.untyped]) }
-      def attributes; end
+  sig { params(key: T.untyped).returns(T.untyped) }
+  def object(key); end
 
-      sig { returns(Numeric) }
-      def height; end
+  sig { returns(T::Array[T.any(::PDF::Reader::Reference, T::Hash[::Symbol, T.untyped])]) }
+  def page_references; end
 
-      sig { returns(Numeric) }
-      def width; end
+  sig { returns(::Float) }
+  def pdf_version; end
 
-      sig { returns(String) }
-      def orientation; end
+  sig { returns(T.untyped) }
+  def sec_handler; end
 
-      sig { returns(T::Array[Numeric]) }
-      def origin; end
+  sig { returns(T::Boolean) }
+  def sec_handler?; end
 
-      sig { params(opts: T::Hash[Symbol, T.untyped]).returns(T::Array[PDF::Reader::TextRun]) }
-      def runs(opts = {}); end
+  sig { returns(::Integer) }
+  def size; end
 
-      sig { params(opts: T::Hash[Symbol, T.untyped]).returns(String) }
-      def text(opts = {}); end
+  sig { params(ref: T.any(::Integer, ::PDF::Reader::Reference)).returns(T::Boolean) }
+  def stream?(ref); end
 
-      sig { params(receivers: T.untyped).void }
-      def walk(*receivers); end
+  sig { returns(T.untyped) }
+  def to_a; end
 
-      sig { returns(String) }
-      def raw_content; end
+  sig { returns(::String) }
+  def to_s; end
 
-      sig { returns(Integer) }
-      def rotate; end
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def trailer; end
 
-      sig { returns(T::Hash[Symbol, T::Array[Numeric]]) }
-      def boxes; end
+  def value?(*args, **_arg1, &blk); end
 
-      sig { returns(T::Hash[Symbol, PDF::Reader::Rectangle]) }
-      def rectangles; end
+  sig { returns(T.untyped) }
+  def values; end
 
-      sig { returns(T::Hash[Symbol, T.untyped]) }
-      def root; end
+  sig { params(ids: T.untyped).returns(T.untyped) }
+  def values_at(*ids); end
 
-      sig { returns(PDF::Reader::Resources) }
-      def resources; end
+  private
 
-      sig { params(receivers: T.untyped, instructions: T.untyped).returns(T.untyped) }
-      def content_stream(receivers, instructions); end
+  sig do
+    params(
+      ref: ::PDF::Reader::Reference,
+      obj: T.untyped
+    ).returns(T.nilable(T.any(::Numeric, ::PDF::Reader::Reference, ::PDF::Reader::Stream, ::PDF::Reader::Token, ::String, ::Symbol, T::Array[T.untyped], T::Hash[T.untyped, T.untyped])))
+  end
+  def decrypt(ref, obj); end
 
-      sig { params(receivers: T.untyped, name: T.untyped, params: T.untyped).returns(T.untyped) }
-      def callback(receivers, name, params = []); end
+  sig do
+    params(
+      key: T.untyped,
+      seen: T::Hash[::Integer, T.untyped]
+    ).returns(T.nilable(T.any(::Numeric, ::PDF::Reader::Reference, ::PDF::Reader::Stream, ::PDF::Reader::Token, ::String, ::Symbol, T::Array[T.untyped], T::Hash[T.untyped, T.untyped])))
+  end
+  def deref_internal!(key, seen); end
 
-      sig { returns(T.untyped) }
-      def page_with_ancestors; end
+  sig { params(input: T.any(::IO, ::String, ::StringIO, ::Tempfile)).returns(T.any(::IO, ::StringIO, ::Tempfile)) }
+  def extract_io_from(input); end
 
-      sig { params(origin: T.untyped).returns(T.untyped) }
-      def ancestors(origin = @page_object[:Parent]); end
+  sig do
+    params(
+      key: ::PDF::Reader::Reference
+    ).returns(T.nilable(T.any(::Numeric, ::PDF::Reader::Reference, ::PDF::Reader::Stream, ::PDF::Reader::Token, ::String, ::Symbol, T::Array[T.untyped], T::Hash[T.untyped, T.untyped])))
+  end
+  def fetch_object(key); end
 
-      sig { params(obj: T::Hash[T.untyped, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
-      def select_inheritable(obj); end
-    end
+  sig do
+    params(
+      key: ::PDF::Reader::Reference
+    ).returns(T.nilable(T.any(::Numeric, ::PDF::Reader::Reference, ::PDF::Reader::Stream, ::PDF::Reader::Token, ::String, ::Symbol, T::Array[T.untyped], T::Hash[T.untyped, T.untyped])))
+  end
+  def fetch_object_stream(key); end
 
-    class PageLayout
-      DEFAULT_FONT_SIZE = 12
+  sig do
+    params(
+      obj: T.any(::PDF::Reader::Reference, T::Hash[::Symbol, T.untyped])
+    ).returns(T::Array[T.any(::PDF::Reader::Reference, T::Hash[::Symbol, T.untyped])])
+  end
+  def get_page_objects(obj); end
 
-      sig { params(runs: T::Array[PDF::Reader::TextRun], mediabox: T.any(T::Array[Numeric], PDF::Reader::Rectangle)).void }
-      def initialize(runs, mediabox); end
+  sig { params(offset: ::Integer).returns(::PDF::Reader::Buffer) }
+  def new_buffer(offset = T.unsafe(nil)); end
 
-      sig { returns(String) }
-      def to_s; end
+  sig { returns(T::Hash[::PDF::Reader::Reference, ::PDF::Reader::ObjectStream]) }
+  def object_streams; end
 
-      sig { params(rows: T.untyped).returns(T.untyped) }
-      def interesting_rows(rows); end
+  sig { params(input: ::String).returns(::String) }
+  def read_as_binary(input); end
 
-      sig { returns(T.untyped) }
-      def row_count; end
+  sig { returns(::Float) }
+  def read_version; end
 
-      sig { returns(T.untyped) }
-      def col_count; end
+  sig { returns(PDF::Reader::XRef[::PDF::Reader::Reference]) }
+  def xref; end
+end
 
-      sig { returns(T.untyped) }
-      def row_multiplier; end
+class PDF::Reader::ObjectStream
+  sig { params(stream: ::PDF::Reader::Stream).void }
+  def initialize(stream); end
 
-      sig { returns(T.untyped) }
-      def col_multiplier; end
+  sig do
+    params(
+      objid: ::Integer
+    ).returns(T.nilable(T.any(::Numeric, ::PDF::Reader::Reference, ::PDF::Reader::Token, ::String, ::Symbol, T::Array[T.untyped], T::Hash[T.untyped, T.untyped])))
+  end
+  def [](objid); end
 
-      sig { params(collection: T.untyped).returns(T.untyped) }
-      def mean(collection); end
+  sig { returns(::Integer) }
+  def size; end
 
-      sig { params(collection: T.untyped).returns(T.untyped) }
-      def median(collection); end
+  private
 
-      sig { params(runs: T.untyped).returns(T.untyped) }
-      def merge_runs(runs); end
+  sig { returns(::PDF::Reader::Buffer) }
+  def buffer; end
 
-      sig { params(chars: T::Array[PDF::Reader::TextRun]).returns(T::Array[PDF::Reader::TextRun]) }
-      def group_chars_into_runs(chars); end
+  sig { returns(::Integer) }
+  def first; end
 
-      sig { params(haystack: T.untyped, needle: T.untyped, index: T.untyped).returns(T.untyped) }
-      def local_string_insert(haystack, needle, index); end
+  sig { returns(T::Hash[::Integer, ::Integer]) }
+  def offsets; end
+end
 
-      sig { params(mediabox: T.untyped).returns(T.untyped) }
-      def process_mediabox(mediabox); end
+class PDF::Reader::OverlappingRunsFilter
+  class << self
+    sig do
+      params(
+        sweep_line_status: T::Array[::PDF::Reader::TextRun],
+        event_point: ::PDF::Reader::EventPoint
+      ).returns(T::Boolean)
     end
+    def detect_intersection(sweep_line_status, event_point); end
 
-    class PageState
-      DEFAULT_GRAPHICS_STATE = {
-        :char_spacing   => 0,
-        :word_spacing   => 0,
-        :h_scaling      => 1.0,
-        :text_leading   => 0,
-        :text_font      => nil,
-        :text_font_size => nil,
-        :text_mode      => 0,
-        :text_rise      => 0,
-        :text_knockout  => 0
-      }
+    sig { params(runs: T::Array[::PDF::Reader::TextRun]).returns(T::Array[::PDF::Reader::TextRun]) }
+    def exclude_redundant_runs(runs); end
+  end
+end
 
-      sig { params(page: T.untyped).void }
-      def initialize(page); end
+PDF::Reader::OverlappingRunsFilter::OVERLAPPING_THRESHOLD = T.let(T.unsafe(nil), Float)
 
-      sig { returns(T.untyped) }
-      def save_graphics_state; end
+class PDF::Reader::Page
+  extend ::Forwardable
 
-      sig { returns(T.untyped) }
-      def restore_graphics_state; end
+  sig { params(objects: ::PDF::Reader::ObjectHash, pagenum: ::Integer, options: T::Hash[::Symbol, T.untyped]).void }
+  def initialize(objects, pagenum, options = T.unsafe(nil)); end
 
-      sig do
-        params(
-          a: T.untyped,
-          b: T.untyped,
-          c: T.untyped,
-          d: T.untyped,
-          e: T.untyped,
-          f: T.untyped
-        ).returns(T.untyped)
-      end
-      def concatenate_matrix(a, b, c, d, e, f); end
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def attributes; end
 
-      sig { returns(T.untyped) }
-      def begin_text_object; end
+  sig { returns(T::Hash[::Symbol, T::Array[::Numeric]]) }
+  def boxes; end
 
-      sig { returns(T.untyped) }
-      def end_text_object; end
+  sig { returns(T.any(::PDF::Reader::ObjectCache, T::Hash[T.untyped, T.untyped])) }
+  def cache; end
 
-      sig { params(char_spacing: T.untyped).returns(T.untyped) }
-      def set_character_spacing(char_spacing); end
+  def color_spaces(*args, **_arg1, &block); end
+  def fonts(*args, **_arg1, &block); end
+  def graphic_states(*args, **_arg1, &block); end
 
-      sig { params(h_scaling: T.untyped).returns(T.untyped) }
-      def set_horizontal_text_scaling(h_scaling); end
+  sig { returns(::Numeric) }
+  def height; end
 
-      sig { params(label: T.untyped, size: T.untyped).returns(T.untyped) }
-      def set_text_font_and_size(label, size); end
+  sig { returns(::String) }
+  def inspect; end
 
-      sig { returns(T.untyped) }
-      def font_size; end
+  sig { returns(::Integer) }
+  def number; end
 
-      sig { params(leading: T.untyped).returns(T.untyped) }
-      def set_text_leading(leading); end
+  sig { returns(::PDF::Reader::ObjectHash) }
+  def objects; end
 
-      sig { params(mode: T.untyped).returns(T.untyped) }
-      def set_text_rendering_mode(mode); end
+  sig { returns(::String) }
+  def orientation; end
 
-      sig { params(rise: T.untyped).returns(T.untyped) }
-      def set_text_rise(rise); end
+  sig { returns(T::Array[::Numeric]) }
+  def origin; end
 
-      sig { params(word_spacing: T.untyped).returns(T.untyped) }
-      def set_word_spacing(word_spacing); end
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def page_object; end
 
-      sig { params(x: T.untyped, y: T.untyped).returns(T.untyped) }
-      def move_text_position(x, y); end
+  def patterns(*args, **_arg1, &block); end
+  def procedure_sets(*args, **_arg1, &block); end
+  def properties(*args, **_arg1, &block); end
 
-      sig { params(x: T.untyped, y: T.untyped).returns(T.untyped) }
-      def move_text_position_and_set_leading(x, y); end
+  sig { returns(::String) }
+  def raw_content; end
 
-      sig do
-        params(
-          a: T.untyped,
-          b: T.untyped,
-          c: T.untyped,
-          d: T.untyped,
-          e: T.untyped,
-          f: T.untyped
-        ).returns(T.untyped)
-      end
-      def set_text_matrix_and_text_line_matrix(a, b, c, d, e, f); end
+  sig { returns(T::Hash[::Symbol, ::PDF::Reader::Rectangle]) }
+  def rectangles; end
 
-      sig { returns(T.untyped) }
-      def move_to_start_of_next_line; end
+  sig { returns(::Integer) }
+  def rotate; end
 
-      sig { params(params: T.untyped).returns(T.untyped) }
-      def show_text_with_positioning(params); end
+  sig { params(opts: T::Hash[::Symbol, T.untyped]).returns(T::Array[::PDF::Reader::TextRun]) }
+  def runs(opts = T.unsafe(nil)); end
 
-      sig { params(str: T.untyped).returns(T.untyped) }
-      def move_to_next_line_and_show_text(str); end
+  def shadings(*args, **_arg1, &block); end
 
-      sig { params(aw: T.untyped, ac: T.untyped, string: T.untyped).returns(T.untyped) }
-      def set_spacing_next_line_show_text(aw, ac, string); end
+  sig { params(opts: T::Hash[::Symbol, T.untyped]).returns(::String) }
+  def text(opts = T.unsafe(nil)); end
 
-      sig { params(label: T.untyped).returns(T.untyped) }
-      def invoke_xobject(label); end
+  def to_s(*args, **_arg1, &blk); end
 
-      sig { params(x: T.untyped, y: T.untyped).returns(T.untyped) }
-      def ctm_transform(x, y); end
+  sig { params(receivers: T.untyped).returns(T.untyped) }
+  def walk(*receivers); end
 
-      sig { params(x: T.untyped, y: T.untyped).returns(T.untyped) }
-      def trm_transform(x, y); end
+  sig { returns(::Numeric) }
+  def width; end
 
-      sig { returns(T.untyped) }
-      def current_font; end
+  def xobjects(*args, **_arg1, &block); end
 
-      sig { params(label: T.untyped).returns(T.untyped) }
-      def find_font(label); end
+  private
 
-      sig { params(label: T.untyped).returns(T.untyped) }
-      def find_color_space(label); end
+  sig { params(origin: T.untyped, seen: T::Set[::Integer]).returns(T.untyped) }
+  def ancestors(origin = T.unsafe(nil), seen = T.unsafe(nil)); end
 
-      sig { params(label: T.untyped).returns(T.untyped) }
-      def find_xobject(label); end
+  sig { params(receivers: T::Array[::Object], name: ::Symbol, params: T::Array[T.untyped]).void }
+  def callback(receivers, name, params = T.unsafe(nil)); end
 
-      sig { returns(T.untyped) }
-      def stack_depth; end
+  sig { params(receivers: T::Array[T.untyped], instructions: ::String).void }
+  def content_stream(receivers, instructions); end
 
-      sig { returns(T.untyped) }
-      def clone_state; end
+  sig { returns(T.untyped) }
+  def page_with_ancestors; end
 
-      sig { params(w0: T.untyped, tj: T.untyped, word_boundary: T.untyped).returns(T.untyped) }
-      def process_glyph_displacement(w0, tj, word_boundary); end
+  sig { returns(::PDF::Reader::Resources) }
+  def resources; end
 
-      sig { returns(T.untyped) }
-      def text_rendering_matrix; end
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def root; end
 
-      sig { returns(T.untyped) }
-      def ctm; end
+  sig { params(obj: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) }
+  def select_inheritable(obj); end
+end
 
-      sig { returns(T.untyped) }
-      def state; end
+class PDF::Reader::PageLayout
+  sig do
+    params(
+      runs: T::Array[::PDF::Reader::TextRun],
+      mediabox: T.any(::PDF::Reader::Rectangle, T::Array[::Numeric])
+    ).void
+  end
+  def initialize(runs, mediabox); end
 
-      sig { params(raw_fonts: T.untyped).returns(T.untyped) }
-      def build_fonts(raw_fonts); end
+  sig { returns(::String) }
+  def to_s; end
 
-      sig { returns(T.untyped) }
-      def identity_matrix; end
-    end
+  private
 
-    class PageTextReceiver
-      extend Forwardable
-      SPACE = " "
+  sig { returns(T.untyped) }
+  def col_count; end
 
-      sig { returns(T.untyped) }
-      attr_reader :state
+  sig { returns(T.untyped) }
+  def col_multiplier; end
 
-      sig { returns(T.untyped) }
-      attr_reader :options
+  sig { params(rows: T.untyped).returns(T.untyped) }
+  def interesting_rows(rows); end
 
-      sig { params(page: T.untyped).returns(T.untyped) }
-      def page=(page); end
+  sig { params(haystack: T.untyped, needle: T.untyped, index: T.untyped).returns(T.untyped) }
+  def local_string_insert(haystack, needle, index); end
 
-      sig { returns(T.untyped) }
-      def content; end
+  sig { params(collection: T.untyped).returns(T.untyped) }
+  def mean(collection); end
 
-      sig { params(string: String).void }
-      def show_text(string); end
+  sig { params(collection: T.untyped).returns(T.untyped) }
+  def median(collection); end
 
-      sig { params(params: T::Array[T.untyped]).void }
-      def show_text_with_positioning(params); end
+  sig { returns(::Numeric) }
+  def page_height; end
 
-      sig { params(str: String).void }
-      def move_to_next_line_and_show_text(str); end
+  sig { returns(::Numeric) }
+  def page_width; end
 
-      sig { params(opts: T::Hash[Symbol, T.untyped]).returns(T::Array[PDF::Reader::TextRun]) }
-      def runs(opts = {}); end
+  sig { params(mediabox: T.untyped).returns(T.untyped) }
+  def process_mediabox(mediabox); end
 
-      sig { params(aw: Numeric, ac: Numeric, string: String).void }
-      def set_spacing_next_line_show_text(aw, ac, string); end
+  sig { returns(T.untyped) }
+  def row_count; end
 
-      sig { params(label: T.untyped).returns(T.untyped) }
-      def invoke_xobject(label); end
+  sig { returns(T.untyped) }
+  def row_multiplier; end
+end
 
-      sig { params(string: String).void }
-      def internal_show_text(string); end
+PDF::Reader::PageLayout::DEFAULT_FONT_SIZE = T.let(T.unsafe(nil), Integer)
+
+class PDF::Reader::PageState
+  sig { params(page: T.untyped).void }
+  def initialize(page); end
+
+  def begin_text_object; end
+  def clone_state; end
+  def concatenate_matrix(a, b, c, d, e, f); end
+  def ctm_transform(x, y); end
+  def current_font; end
+  def end_text_object; end
+  def find_color_space(label); end
+  def find_font(label); end
+  def find_xobject(label); end
+  def font_size; end
+  def invoke_xobject(label); end
+  def move_text_position(x, y); end
+  def move_text_position_and_set_leading(x, y); end
+  def move_to_next_line_and_show_text(str); end
+  def move_to_start_of_next_line; end
+  def process_glyph_displacement(w0, tj, word_boundary); end
+
+  sig { returns(T.untyped) }
+  def restore_graphics_state; end
+
+  sig { returns(T.untyped) }
+  def save_graphics_state; end
+
+  def set_character_spacing(char_spacing); end
+  def set_horizontal_text_scaling(h_scaling); end
+  def set_spacing_next_line_show_text(aw, ac, string); end
+  def set_text_font_and_size(label, size); end
+  def set_text_leading(leading); end
+  def set_text_matrix_and_text_line_matrix(a, b, c, d, e, f); end
+  def set_text_rendering_mode(mode); end
+  def set_text_rise(rise); end
+  def set_word_spacing(word_spacing); end
+  def show_text_with_positioning(params); end
+  def stack_depth; end
+  def trm_transform(x, y); end
+
+  private
+
+  def build_fonts(raw_fonts); end
+  def ctm; end
+  def identity_matrix; end
+  def state; end
+  def text_rendering_matrix; end
+end
 
-      sig { params(x: T.untyped, y: T.untyped).returns(T.untyped) }
-      def apply_rotation(x, y); end
-    end
+PDF::Reader::PageState::DEFAULT_GRAPHICS_STATE = T.let(T.unsafe(nil), Hash)
+
+class PDF::Reader::PageTextReceiver
+  extend ::Forwardable
+
+  def begin_text_object(*args, **_arg1, &block); end
+  def concatenate_matrix(*args, **_arg1, &block); end
+  def content; end
+  def end_text_object(*args, **_arg1, &block); end
+  def font_size(*args, **_arg1, &block); end
+  def invoke_xobject(label); end
+  def move_text_position(*args, **_arg1, &block); end
+  def move_text_position_and_set_leading(*args, **_arg1, &block); end
+  def move_to_next_line_and_show_text(str); end
+  def move_to_start_of_next_line(*args, **_arg1, &block); end
+
+  sig { returns(T.untyped) }
+  def options; end
+
+  def page=(page); end
+  def restore_graphics_state(*args, **_arg1, &block); end
+  def runs(opts = T.unsafe(nil)); end
+  def save_graphics_state(*args, **_arg1, &block); end
+  def set_character_spacing(*args, **_arg1, &block); end
+  def set_horizontal_text_scaling(*args, **_arg1, &block); end
+  def set_spacing_next_line_show_text(aw, ac, string); end
+  def set_text_font_and_size(*args, **_arg1, &block); end
+  def set_text_leading(*args, **_arg1, &block); end
+  def set_text_matrix_and_text_line_matrix(*args, **_arg1, &block); end
+  def set_text_rendering_mode(*args, **_arg1, &block); end
+  def set_text_rise(*args, **_arg1, &block); end
+  def set_word_spacing(*args, **_arg1, &block); end
+  def show_text(string); end
+  def show_text_with_positioning(params); end
+
+  sig { returns(T.untyped) }
+  def state; end
+
+  private
+
+  def apply_rotation(x, y); end
+  def group_chars_into_runs(chars); end
+  def internal_show_text(string); end
+  def merge_runs(runs); end
+end
 
-    class PagesStrategy
-      OPERATORS = {
-      'b'   => :close_fill_stroke,
-      'B'   => :fill_stroke,
-      'b*'  => :close_fill_stroke_with_even_odd,
-      'B*'  => :fill_stroke_with_even_odd,
-      'BDC' => :begin_marked_content_with_pl,
-      'BI'  => :begin_inline_image,
-      'BMC' => :begin_marked_content,
-      'BT'  => :begin_text_object,
-      'BX'  => :begin_compatibility_section,
-      'c'   => :append_curved_segment,
-      'cm'  => :concatenate_matrix,
-      'CS'  => :set_stroke_color_space,
-      'cs'  => :set_nonstroke_color_space,
-      'd'   => :set_line_dash,
-      'd0'  => :set_glyph_width,
-      'd1'  => :set_glyph_width_and_bounding_box,
-      'Do'  => :invoke_xobject,
-      'DP'  => :define_marked_content_with_pl,
-      'EI'  => :end_inline_image,
-      'EMC' => :end_marked_content,
-      'ET'  => :end_text_object,
-      'EX'  => :end_compatibility_section,
-      'f'   => :fill_path_with_nonzero,
-      'F'   => :fill_path_with_nonzero,
-      'f*'  => :fill_path_with_even_odd,
-      'G'   => :set_gray_for_stroking,
-      'g'   => :set_gray_for_nonstroking,
-      'gs'  => :set_graphics_state_parameters,
-      'h'   => :close_subpath,
-      'i'   => :set_flatness_tolerance,
-      'ID'  => :begin_inline_image_data,
-      'j'   => :set_line_join_style,
-      'J'   => :set_line_cap_style,
-      'K'   => :set_cmyk_color_for_stroking,
-      'k'   => :set_cmyk_color_for_nonstroking,
-      'l'   => :append_line,
-      'm'   => :begin_new_subpath,
-      'M'   => :set_miter_limit,
-      'MP'  => :define_marked_content_point,
-      'n'   => :end_path,
-      'q'   => :save_graphics_state,
-      'Q'   => :restore_graphics_state,
-      're'  => :append_rectangle,
-      'RG'  => :set_rgb_color_for_stroking,
-      'rg'  => :set_rgb_color_for_nonstroking,
-      'ri'  => :set_color_rendering_intent,
-      's'   => :close_and_stroke_path,
-      'S'   => :stroke_path,
-      'SC'  => :set_color_for_stroking,
-      'sc'  => :set_color_for_nonstroking,
-      'SCN' => :set_color_for_stroking_and_special,
-      'scn' => :set_color_for_nonstroking_and_special,
-      'sh'  => :paint_area_with_shading_pattern,
-      'T*'  => :move_to_start_of_next_line,
-      'Tc'  => :set_character_spacing,
-      'Td'  => :move_text_position,
-      'TD'  => :move_text_position_and_set_leading,
-      'Tf'  => :set_text_font_and_size,
-      'Tj'  => :show_text,
-      'TJ'  => :show_text_with_positioning,
-      'TL'  => :set_text_leading,
-      'Tm'  => :set_text_matrix_and_text_line_matrix,
-      'Tr'  => :set_text_rendering_mode,
-      'Ts'  => :set_text_rise,
-      'Tw'  => :set_word_spacing,
-      'Tz'  => :set_horizontal_text_scaling,
-      'v'   => :append_curved_segment_initial_point_replicated,
-      'w'   => :set_line_width,
-      'W'   => :set_clipping_path_with_nonzero,
-      'W*'  => :set_clipping_path_with_even_odd,
-      'y'   => :append_curved_segment_final_point_replicated,
-      '\''  => :move_to_next_line_and_show_text,
-      '"'   => :set_spacing_next_line_show_text,
-    }
-    end
+PDF::Reader::PageTextReceiver::SPACE = T.let(T.unsafe(nil), String)
+class PDF::Reader::PagesStrategy; end
+PDF::Reader::PagesStrategy::OPERATORS = T.let(T.unsafe(nil), Hash)
 
-    class Parser
-      sig { params(buffer: PDF::Reader::Buffer, objects: T.nilable(PDF::Reader::ObjectHash)).void }
-      def initialize(buffer, objects=nil); end
-
-      sig {
-        params(
-          operators: T::Hash[T.any(String, PDF::Reader::Token), Symbol]
-        ).returns(
-          T.any(PDF::Reader::Reference, PDF::Reader::Token, Numeric, String, Symbol, T::Array[T.untyped], T::Hash[T.untyped, T.untyped], NilClass)
-        )
-      }
-      def parse_token(operators={}); end
-
-      sig {
-        params(
-         id: Integer,
-         gen: Integer
-        ).returns(
-          T.any(PDF::Reader::Reference, PDF::Reader::Token, PDF::Reader::Stream, Numeric, String, Symbol, T::Array[T.untyped], T::Hash[T.untyped, T.untyped], NilClass)
-        )
-      }
-      def object(id, gen); end
-
-      sig { returns(T::Hash[Symbol, T.untyped]) }
-      def dictionary; end
-
-      sig { returns(Symbol) }
-      def pdf_name; end
-
-      sig { returns(T::Array[T.untyped]) }
-      def array; end
-
-      sig { returns(String) }
-      def hex_string; end
-
-      sig { returns(String) }
-      def string; end
-
-      sig { params(dict: T::Hash[Symbol, T.untyped]).returns(PDF::Reader::Stream) }
-      def stream(dict); end
-    end
+class PDF::Reader::Parser
+  sig { params(buffer: ::PDF::Reader::Buffer, objects: T.nilable(::PDF::Reader::ObjectHash)).void }
+  def initialize(buffer, objects = T.unsafe(nil)); end
+
+  sig do
+    params(
+      id: ::Integer,
+      gen: ::Integer
+    ).returns(T.nilable(T.any(::Numeric, ::PDF::Reader::Reference, ::PDF::Reader::Stream, ::PDF::Reader::Token, ::String, ::Symbol, T::Array[T.untyped], T::Hash[T.untyped, T.untyped])))
+  end
+  def object(id, gen); end
 
-    class Point
-      sig do
-        params(
-          x: Numeric,
-          y: Numeric,
-        ).void
-      end
-      def initialize(x, y)
-        @x = T.let(T.unsafe(nil), Numeric)
-        @y = T.let(T.unsafe(nil), Numeric)
-      end
+  sig do
+    params(
+      operators: T::Hash[T.any(::PDF::Reader::Token, ::String), ::Symbol]
+    ).returns(T.nilable(T.any(::Numeric, ::PDF::Reader::Reference, ::PDF::Reader::Token, ::String, ::Symbol, T::Array[T.untyped], T::Hash[T.untyped, T.untyped])))
+  end
+  def parse_token(operators = T.unsafe(nil)); end
 
-      sig { returns(Numeric) }
-      def x; end
+  private
 
-      sig { returns(Numeric) }
-      def y; end
+  sig { returns(T::Array[T.untyped]) }
+  def array; end
 
-      sig { params(other: PDF::Reader::Point).returns(T::Boolean) }
-      def ==(other); end
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def dictionary; end
 
-    end
+  sig { returns(::String) }
+  def hex_string; end
 
-    class PrintReceiver
-      sig { returns(T.untyped) }
-      attr_accessor :callbacks
+  sig { returns(::Symbol) }
+  def pdf_name; end
 
-      sig { void }
-      def initialize; end
+  sig { params(dict: T::Hash[::Symbol, T.untyped]).returns(::PDF::Reader::Stream) }
+  def stream(dict); end
 
-      sig { params(meth: T.untyped).returns(T.untyped) }
-      def respond_to?(meth); end
+  sig { returns(::String) }
+  def string; end
+end
 
-      sig { params(methodname: T.untyped, args: T.untyped).returns(T.untyped) }
-      def method_missing(methodname, *args); end
-    end
+PDF::Reader::Parser::MAPPING = T.let(T.unsafe(nil), Hash)
+PDF::Reader::Parser::STRATEGIES = T.let(T.unsafe(nil), Hash)
+PDF::Reader::Parser::TOKEN_STRATEGY = T.let(T.unsafe(nil), Proc)
 
-    class Rc4SecurityHandler
-      sig { params(key: String).void }
-      def initialize(key)
-        @encrypt_key = T.let(T.unsafe(nil), String)
-      end
+class PDF::Reader::Point
+  sig { params(x: ::Numeric, y: ::Numeric).void }
+  def initialize(x, y); end
 
-      sig { params(buf: T.untyped, ref: T.untyped).returns(T.untyped) }
-      def decrypt(buf, ref); end
-    end
+  sig { params(other: ::PDF::Reader::Point).returns(T::Boolean) }
+  def ==(other); end
 
-    class Rectangle
+  sig { returns(::Numeric) }
+  def x; end
 
-      sig { params(arr: T::Array[Numeric]).returns(PDF::Reader::Rectangle) }
-      def self.from_array(arr); end
+  sig { returns(::Numeric) }
+  def y; end
+end
+
+class PDF::Reader::PrintReceiver
+  sig { params(methodname: ::Symbol, args: T.untyped).void }
+  def method_missing(methodname, *args); end
 
-      sig do
-        params(
-          x1: Numeric,
-          y1: Numeric,
-          x2: Numeric,
-          y2: Numeric
-        ).void
-      end
+  sig { params(meth: T.untyped).returns(T::Boolean) }
+  def respond_to?(meth); end
+end
 
-      def initialize(x1, y1, x2, y2)
-        @bottom_left = T.let(T.unsafe(nil), PDF::Reader::Point)
-        @bottom_right = T.let(T.unsafe(nil), PDF::Reader::Point)
-        @top_left = T.let(T.unsafe(nil), PDF::Reader::Point)
-        @top_right = T.let(T.unsafe(nil), PDF::Reader::Point)
-      end
+class PDF::Reader::Rc4SecurityHandler
+  sig { params(key: ::String).void }
+  def initialize(key); end
 
-      sig { returns(PDF::Reader::Point) }
-      def bottom_left; end
+  sig { params(buf: ::String, ref: ::PDF::Reader::Reference).returns(::String) }
+  def decrypt(buf, ref); end
+end
 
-      sig { returns(PDF::Reader::Point) }
-      def bottom_right; end
+class PDF::Reader::Rectangle
+  sig { params(x1: ::Numeric, y1: ::Numeric, x2: ::Numeric, y2: ::Numeric).void }
+  def initialize(x1, y1, x2, y2); end
 
-      sig { returns(PDF::Reader::Point) }
-      def top_left; end
+  sig { params(other: ::PDF::Reader::Rectangle).returns(T::Boolean) }
+  def ==(other); end
 
-      sig { returns(PDF::Reader::Point) }
-      def top_right; end
+  sig { params(degrees: ::Integer).void }
+  def apply_rotation(degrees); end
 
-      sig { returns(Numeric) }
-      def height; end
+  sig { returns(::PDF::Reader::Point) }
+  def bottom_left; end
 
-      sig { returns(Numeric) }
-      def width; end
+  sig { returns(::PDF::Reader::Point) }
+  def bottom_right; end
 
-      sig { returns(T::Array[Numeric]) }
-      def to_a; end
+  sig { params(point: ::PDF::Reader::Point).returns(T::Boolean) }
+  def contains?(point); end
 
-      sig { params(degrees: Integer).void }
-      def apply_rotation(degrees); end
+  sig { returns(::Numeric) }
+  def height; end
 
-      sig { params(point: PDF::Reader::Point).void }
-      def contains?(point); end
+  sig { returns(T::Array[::Numeric]) }
+  def to_a; end
 
-      sig { params(other: PDF::Reader::Rectangle).void }
-      def ==(other); end
+  sig { returns(::PDF::Reader::Point) }
+  def top_left; end
 
-      sig { params(x1: Numeric, y1: Numeric, x2: Numeric, y2: Numeric).void }
-      def set_corners(x1, y1, x2, y2); end
-    end
+  sig { returns(::PDF::Reader::Point) }
+  def top_right; end
 
-    class Reference
-      sig { returns(T.untyped) }
-      attr_reader :id
+  sig { returns(::Numeric) }
+  def width; end
 
-      sig { returns(T.untyped) }
-      attr_reader :gen
+  private
 
-      sig { params(id: T.untyped, gen: T.untyped).void }
-      def initialize(id, gen); end
+  sig { params(x1: ::Numeric, y1: ::Numeric, x2: ::Numeric, y2: ::Numeric).void }
+  def set_corners(x1, y1, x2, y2); end
 
-      sig { returns(T.untyped) }
-      def to_a; end
+  class << self
+    sig { params(arr: T::Array[::Numeric]).returns(::PDF::Reader::Rectangle) }
+    def from_array(arr); end
+  end
+end
 
-      sig { returns(T.untyped) }
-      def to_i; end
+class PDF::Reader::Reference
+  sig { params(id: ::Integer, gen: ::Integer).void }
+  def initialize(id, gen); end
 
-      sig { params(obj: T.untyped).returns(T.untyped) }
-      def ==(obj); end
+  sig { params(obj: ::Object).returns(T::Boolean) }
+  def ==(obj); end
 
-      sig { returns(T.untyped) }
-      def hash; end
-    end
+  def eql?(*args, **_arg1, &blk); end
 
-    class RegisterReceiver
-      sig { returns(T.untyped) }
-      attr_accessor :callbacks
+  sig { returns(::Integer) }
+  def gen; end
 
-      sig { void }
-      def initialize; end
+  sig { returns(::Integer) }
+  def hash; end
 
-      sig { params(meth: T.untyped).returns(T.untyped) }
-      def respond_to?(meth); end
+  sig { returns(::Integer) }
+  def id; end
 
-      sig { params(methodname: T.untyped, args: T.untyped).returns(T.untyped) }
-      def method_missing(methodname, *args); end
+  sig { returns(T::Array[::PDF::Reader::Reference]) }
+  def to_a; end
 
-      sig { params(methodname: T.untyped).returns(T.untyped) }
-      def count(methodname); end
+  sig { returns(::Integer) }
+  def to_i; end
+end
 
-      sig { params(methodname: T.untyped).returns(T.untyped) }
-      def all(methodname); end
+class PDF::Reader::RegisterReceiver
+  sig { void }
+  def initialize; end
 
-      sig { params(methodname: T.untyped).returns(T.untyped) }
-      def all_args(methodname); end
+  sig { params(methodname: ::Symbol).returns(T::Array[T::Hash[::Symbol, T.untyped]]) }
+  def all(methodname); end
 
-      sig { params(methodname: T.untyped).returns(T.untyped) }
-      def first_occurance_of(methodname); end
+  sig { params(methodname: ::Symbol).returns(T::Array[T::Array[T.untyped]]) }
+  def all_args(methodname); end
 
-      sig { params(methodname: T.untyped).returns(T.untyped) }
-      def final_occurance_of(methodname); end
+  sig { returns(T::Array[T::Hash[::Symbol, T.untyped]]) }
+  def callbacks; end
 
-      sig { params(methods: T.untyped).returns(T.untyped) }
-      def series(*methods); end
-    end
+  def callbacks=(_arg0); end
 
-    module ResourceMethods
-      extend T::Helpers
+  sig { params(methodname: ::Symbol).returns(::Integer) }
+  def count(methodname); end
 
-      sig { returns(T.untyped) }
-      def color_spaces; end
+  sig { params(methodname: ::Symbol).returns(T.nilable(T::Hash[::Symbol, T.untyped])) }
+  def final_occurance_of(methodname); end
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
-      def fonts; end
+  sig { params(methodname: ::Symbol).returns(T.nilable(T::Hash[::Symbol, T.untyped])) }
+  def first_occurance_of(methodname); end
 
-      sig { returns(T.untyped) }
-      def graphic_states; end
+  sig { params(methodname: ::Symbol, args: T.untyped).void }
+  def method_missing(methodname, *args); end
 
-      sig { returns(T.untyped) }
-      def patterns; end
+  sig { params(meth: T.untyped).returns(T::Boolean) }
+  def respond_to?(meth); end
 
-      sig { returns(T.untyped) }
-      def procedure_sets; end
+  sig { params(methods: ::Symbol).returns(T.nilable(T::Array[T::Hash[::Symbol, T.untyped]])) }
+  def series(*methods); end
+end
 
-      sig { returns(T.untyped) }
-      def properties; end
+class PDF::Reader::Resources
+  sig { params(objects: ::PDF::Reader::ObjectHash, resources: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(objects, resources); end
 
-      sig { returns(T.untyped) }
-      def shadings; end
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def color_spaces; end
 
-      sig { returns(T.untyped) }
-      def xobjects; end
-    end
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def fonts; end
 
-    class SecurityHandlerFactory
-      sig { params(encrypt: T.untyped, doc_id: T.untyped, password: T.untyped).returns(T.untyped) }
-      def self.build(encrypt, doc_id, password); end
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def graphic_states; end
 
-      sig { params(encrypt: T.untyped, doc_id: T.untyped, password: T.untyped).returns(T.untyped) }
-      def self.build_standard_handler(encrypt, doc_id, password); end
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def patterns; end
 
-      sig { params(encrypt: T.untyped, doc_id: T.untyped, password: T.untyped).returns(T.untyped) }
-      def self.build_v5_handler(encrypt, doc_id, password); end
+  sig { returns(T::Array[::Symbol]) }
+  def procedure_sets; end
 
-      sig { params(encrypt: T.untyped).returns(T.untyped) }
-      def self.standard?(encrypt); end
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def properties; end
 
-      sig { params(encrypt: T.untyped).returns(T.untyped) }
-      def self.standard_v5?(encrypt); end
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def shadings; end
+
+  sig { returns(T::Hash[::Symbol, ::PDF::Reader::Stream]) }
+  def xobjects; end
+end
+
+class PDF::Reader::SecurityHandlerFactory
+  class << self
+    sig do
+      params(
+        encrypt: T::Hash[::Symbol, T.untyped],
+        doc_id: T.nilable(T::Array[T.untyped]),
+        password: T.nilable(::String)
+      ).returns(T.any(::PDF::Reader::AesV2SecurityHandler, ::PDF::Reader::AesV3SecurityHandler, ::PDF::Reader::NullSecurityHandler, ::PDF::Reader::Rc4SecurityHandler, ::PDF::Reader::UnimplementedSecurityHandler))
     end
+    def build(encrypt, doc_id, password); end
+
+    sig do
+      params(
+        encrypt: T::Hash[::Symbol, T.untyped],
+        doc_id: T::Array[T.untyped],
+        password: ::String
+      ).returns(T.any(::PDF::Reader::AesV2SecurityHandler, ::PDF::Reader::Rc4SecurityHandler))
+    end
+    def build_standard_handler(encrypt, doc_id, password); end
+
+    sig do
+      params(
+        encrypt: T::Hash[::Symbol, T.untyped],
+        doc_id: T::Array[T.untyped],
+        password: ::String
+      ).returns(::PDF::Reader::AesV3SecurityHandler)
+    end
+    def build_v5_handler(encrypt, doc_id, password); end
 
-    class StandardKeyBuilder
-      PassPadBytes = [ 0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41,
-                     0x64, 0x00, 0x4e, 0x56, 0xff, 0xfa, 0x01, 0x08,
-                     0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80,
-                     0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a ]
+    sig { params(encrypt: T::Hash[::Symbol, T.untyped]).returns(T::Boolean) }
+    def standard?(encrypt); end
 
-      sig { params(opts: T::Hash[Symbol, T.untyped]).void }
-      def initialize(opts = {}); end
+    sig { params(encrypt: T::Hash[::Symbol, T.untyped]).returns(T.untyped) }
+    def standard_v5?(encrypt); end
+  end
+end
 
-      sig { params(pass: String).returns(String) }
-      def key(pass); end
+class PDF::Reader::StandardKeyBuilder
+  sig { params(opts: T::Hash[::Symbol, T.untyped]).void }
+  def initialize(opts = T.unsafe(nil)); end
 
-      sig { params(p: T.untyped).returns(T.untyped) }
-      def pad_pass(p = ""); end
+  sig { params(pass: ::String).returns(::String) }
+  def key(pass = T.unsafe(nil)); end
 
-      sig { params(buf: T.untyped, int: T.untyped).returns(T.untyped) }
-      def xor_each_byte(buf, int); end
+  private
 
-      sig { params(pass: T.untyped).returns(T.untyped) }
-      def auth_owner_pass(pass); end
+  sig { params(pass: ::String).returns(T.nilable(::String)) }
+  def auth_owner_pass(pass); end
 
-      sig { params(pass: T.untyped).returns(T.untyped) }
-      def auth_user_pass(pass); end
+  sig { params(pass: ::String).returns(T.nilable(::String)) }
+  def auth_user_pass(pass); end
 
-      sig { params(user_pass: T.untyped).returns(T.untyped) }
-      def make_file_key(user_pass); end
-    end
+  sig { params(user_pass: ::String).returns(::String) }
+  def make_file_key(user_pass); end
 
-    class Stream
-      sig { returns(T::Hash[Symbol, T.untyped]) }
-      attr_accessor :hash
+  sig { params(p: T.nilable(::String)).returns(::String) }
+  def pad_pass(p = T.unsafe(nil)); end
 
-      sig { returns(String) }
-      attr_accessor :data
+  sig { params(buf: ::String, int: ::Integer).returns(::String) }
+  def xor_each_byte(buf, int); end
+end
 
-      sig { params(hash: T::Hash[Symbol, T.untyped], data: String).void }
-      def initialize(hash, data)
-        @hash = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped])
-        @data = T.let(T.unsafe(nil), String)
-        @udata = T.let(T.unsafe(nil), T.nilable(String))
-      end
+PDF::Reader::StandardKeyBuilder::PassPadBytes = T.let(T.unsafe(nil), Array)
 
-      sig { returns(String) }
-      def unfiltered_data; end
-    end
+class PDF::Reader::Stream
+  sig { params(hash: T::Hash[::Symbol, T.untyped], data: ::String).void }
+  def initialize(hash, data); end
 
-    class SynchronizedCache
-      sig { void }
-      def initialize; end
+  sig { returns(::String) }
+  def data; end
 
-      sig { params(key: T.untyped).returns(T.untyped) }
-      def [](key); end
+  def data=(_arg0); end
 
-      sig { params(key: T.untyped, value: T.untyped).returns(T.untyped) }
-      def []=(key, value); end
-    end
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def hash; end
 
-    class TextRun
-      include Comparable
+  def hash=(_arg0); end
 
-      sig { returns(T.untyped) }
-      attr_reader :x
+  sig { returns(::String) }
+  def unfiltered_data; end
+end
 
-      sig { returns(T.untyped) }
-      attr_reader :y
+class PDF::Reader::SynchronizedCache
+  sig { void }
+  def initialize; end
 
-      sig { returns(T.untyped) }
-      attr_reader :width
+  sig { params(key: ::Object).returns(T.untyped) }
+  def [](key); end
 
-      sig { returns(T.untyped) }
-      attr_reader :font_size
+  sig { params(key: ::Object, value: T.nilable(::Object)).returns(T.untyped) }
+  def []=(key, value); end
+end
 
-      sig { returns(T.untyped) }
-      attr_reader :text
+class PDF::Reader::TextRun
+  include ::Comparable
 
-      sig do
-        params(
-          x: T.untyped,
-          y: T.untyped,
-          width: T.untyped,
-          font_size: T.untyped,
-          text: T.untyped
-        ).void
-      end
-      def initialize(x, y, width, font_size, text); end
+  sig { params(x: ::Numeric, y: ::Numeric, width: ::Numeric, font_size: ::Numeric, text: ::String).void }
+  def initialize(x, y, width, font_size, text); end
 
-      sig { params(other: T.untyped).returns(T.untyped) }
-      def <=>(other); end
+  sig { params(other: ::PDF::Reader::TextRun).returns(::PDF::Reader::TextRun) }
+  def +(other); end
 
-      sig { returns(T.untyped) }
-      def endx; end
+  sig { params(other: ::PDF::Reader::Point).returns(::Numeric) }
+  def <=>(other); end
 
-      sig { returns(T.untyped) }
-      def endy; end
+  sig { returns(::Numeric) }
+  def endx; end
 
-      sig { returns(T.untyped) }
-      def mean_character_width; end
+  sig { returns(::Numeric) }
+  def endy; end
 
-      sig { params(other: PDF::Reader::TextRun).returns(T::Boolean) }
-      def mergable?(other); end
+  sig { returns(::Numeric) }
+  def font_size; end
 
-      sig { params(other: PDF::Reader::TextRun).returns(PDF::Reader::TextRun) }
-      def +(other); end
+  sig { returns(::String) }
+  def inspect; end
 
-      sig { returns(T.untyped) }
-      def inspect; end
+  sig { params(other_run: ::PDF::Reader::TextRun).returns(T::Boolean) }
+  def intersect?(other_run); end
 
-      sig { params(other_run: T.untyped).returns(T.untyped) }
-      def intersect?(other_run); end
+  sig { params(other_run: ::PDF::Reader::TextRun).returns(::Numeric) }
+  def intersection_area_percent(other_run); end
 
-      sig { params(other_run: T.untyped).returns(T.untyped) }
-      def intersection_area_percent(other_run); end
+  sig { returns(::Numeric) }
+  def mean_character_width; end
 
-      sig { returns(T.untyped) }
-      def area; end
+  sig { params(other: ::PDF::Reader::TextRun).returns(T::Boolean) }
+  def mergable?(other); end
 
-      sig { returns(T.untyped) }
-      def mergable_range; end
+  sig { returns(::PDF::Reader::Point) }
+  def origin; end
 
-      sig { returns(T.untyped) }
-      def character_count; end
-    end
+  sig { returns(::String) }
+  def text; end
 
-    class Token < String
-      sig { params(val: T.untyped).void }
-      def initialize(val); end
-    end
+  def to_s(*args, **_arg1, &blk); end
 
-    class TransformationMatrix
-      sig { returns(T.untyped) }
-      attr_reader :a
-
-      sig { returns(T.untyped) }
-      attr_reader :b
-
-      sig { returns(T.untyped) }
-      attr_reader :c
-
-      sig { returns(T.untyped) }
-      attr_reader :d
-
-      sig { returns(T.untyped) }
-      attr_reader :e
-
-      sig { returns(T.untyped) }
-      attr_reader :f
-
-      sig do
-        params(
-          a: T.untyped,
-          b: T.untyped,
-          c: T.untyped,
-          d: T.untyped,
-          e: T.untyped,
-          f: T.untyped
-        ).void
-      end
-      def initialize(a, b, c, d, e, f); end
-
-      sig { returns(T.untyped) }
-      def inspect; end
-
-      sig { returns(T.untyped) }
-      def to_a; end
-
-      sig do
-        params(
-          a: T.untyped,
-          b: T.untyped,
-          c: T.untyped,
-          d: T.untyped,
-          e: T.untyped,
-          f: T.untyped
-        ).returns(T.untyped)
-      end
-      def multiply!(a, b = nil, c = nil, d = nil, e = nil, f = nil); end
-
-      sig { params(e2: T.untyped).returns(T.untyped) }
-      def horizontal_displacement_multiply!(e2); end
-
-      sig do
-        params(
-          a2: T.untyped,
-          b2: T.untyped,
-          c2: T.untyped,
-          d2: T.untyped,
-          e2: T.untyped,
-          f2: T.untyped
-        ).returns(T.untyped)
-      end
-      def horizontal_displacement_multiply_reversed!(a2, b2, c2, d2, e2, f2); end
-
-      sig do
-        params(
-          a2: T.untyped,
-          b2: T.untyped,
-          c2: T.untyped,
-          d2: T.untyped,
-          e2: T.untyped,
-          f2: T.untyped
-        ).returns(T.untyped)
-      end
-      def xy_scaling_multiply!(a2, b2, c2, d2, e2, f2); end
-
-      sig do
-        params(
-          a2: T.untyped,
-          b2: T.untyped,
-          c2: T.untyped,
-          d2: T.untyped,
-          e2: T.untyped,
-          f2: T.untyped
-        ).returns(T.untyped)
-      end
-      def xy_scaling_multiply_reversed!(a2, b2, c2, d2, e2, f2); end
-
-      sig do
-        params(
-          a2: T.untyped,
-          b2: T.untyped,
-          c2: T.untyped,
-          d2: T.untyped,
-          e2: T.untyped,
-          f2: T.untyped
-        ).returns(T.untyped)
-      end
-      def regular_multiply!(a2, b2, c2, d2, e2, f2); end
-
-      sig do
-        params(
-          a2: T.untyped,
-          b2: T.untyped,
-          c2: T.untyped,
-          d2: T.untyped,
-          e2: T.untyped,
-          f2: T.untyped
-        ).returns(T.untyped)
-      end
-      def faster_multiply!(a2, b2, c2, d2, e2, f2); end
-    end
+  sig { returns(::Numeric) }
+  def width; end
 
-    class TypeCheck
+  sig { returns(::Numeric) }
+  def x; end
 
-      sig { params(obj: T.untyped).returns(Numeric) }
-      def self.cast_to_numeric!(obj); end
+  sig { returns(::Numeric) }
+  def y; end
 
-      sig { params(string: T.untyped).returns(String) }
-      def self.cast_to_string!(string); end
+  private
 
-      sig { params(obj: T.untyped).returns(T.nilable(Symbol)) }
-      def self.cast_to_symbol(obj); end
-    end
+  sig { returns(::Numeric) }
+  def area; end
 
-    class ValidatingReceiver
-      sig { params(wrapped: T.untyped).void }
-      def initialize(wrapped)
-        @wrapped = T.let(T.unsafe(nil), T.untyped)
-      end
+  sig { returns(::Float) }
+  def character_count; end
 
-      sig { params(page: PDF::Reader::Page).void }
-      def page=(page); end
+  sig { returns(T::Range[::Numeric]) }
+  def mergable_range; end
+end
 
-      sig { params(args: T.untyped).void }
-      def save_graphics_state(*args); end
+class PDF::Reader::Token < ::String
+  sig { params(val: T.untyped).void }
+  def initialize(val); end
+end
 
-      sig { params(args: T.untyped).void }
-      def restore_graphics_state(*args); end
+class PDF::Reader::TransformationMatrix
+  sig { params(a: ::Numeric, b: ::Numeric, c: ::Numeric, d: ::Numeric, e: ::Numeric, f: ::Numeric).void }
+  def initialize(a, b, c, d, e, f); end
 
-      sig { params(args: T.untyped).void }
-      def concatenate_matrix(*args); end
+  sig { returns(::Numeric) }
+  def a; end
 
-      sig { params(args: T.untyped).void }
-      def begin_text_object(*args); end
+  sig { returns(::Numeric) }
+  def b; end
 
-      sig { params(args: T.untyped).void }
-      def end_text_object(*args); end
+  sig { returns(::Numeric) }
+  def c; end
 
-      sig { params(args: T.untyped).void }
-      def set_character_spacing(*args); end
+  sig { returns(::Numeric) }
+  def d; end
 
-      sig { params(args: T.untyped).void }
-      def set_horizontal_text_scaling(*args); end
+  sig { returns(::Numeric) }
+  def e; end
 
-      sig { params(args: T.untyped).void }
-      def set_text_font_and_size(*args); end
+  sig { returns(::Numeric) }
+  def f; end
 
-      sig { params(args: T.untyped).void }
-      def set_text_leading(*args); end
+  sig { params(e2: ::Numeric).void }
+  def horizontal_displacement_multiply!(e2); end
 
-      sig { params(args: T.untyped).void }
-      def set_text_rendering_mode(*args); end
+  sig { returns(::String) }
+  def inspect; end
 
-      sig { params(args: T.untyped).void }
-      def set_text_rise(*args); end
+  sig do
+    params(
+      a: ::Numeric,
+      b: ::Numeric,
+      c: ::Numeric,
+      d: ::Numeric,
+      e: ::Numeric,
+      f: ::Numeric
+    ).returns(::PDF::Reader::TransformationMatrix)
+  end
+  def multiply!(a, b, c, d, e, f); end
 
-      sig { params(args: T.untyped).void }
-      def set_word_spacing(*args); end
+  sig { returns([::Numeric]) }
+  def to_a; end
 
-      sig { params(args: T.untyped).void }
-      def move_text_position(*args); end
+  private
 
-      sig { params(args: T.untyped).void }
-      def move_text_position_and_set_leading(*args); end
+  sig { params(a2: ::Numeric, b2: ::Numeric, c2: ::Numeric, d2: ::Numeric, e2: ::Numeric, f2: ::Numeric).void }
+  def faster_multiply!(a2, b2, c2, d2, e2, f2); end
 
-      sig { params(args: T.untyped).void }
-      def set_text_matrix_and_text_line_matrix(*args); end
+  sig { params(a2: ::Numeric, b2: ::Numeric, c2: ::Numeric, d2: ::Numeric, e2: ::Numeric, f2: ::Numeric).void }
+  def horizontal_displacement_multiply_reversed!(a2, b2, c2, d2, e2, f2); end
 
-      sig { params(args: T.untyped).void }
-      def move_to_start_of_next_line(*args); end
+  sig { params(a2: ::Numeric, b2: ::Numeric, c2: ::Numeric, d2: ::Numeric, e2: ::Numeric, f2: ::Numeric).void }
+  def regular_multiply!(a2, b2, c2, d2, e2, f2); end
 
-      sig { params(args: T.untyped).void }
-      def show_text(*args); end
+  sig { params(a2: ::Numeric, b2: ::Numeric, c2: ::Numeric, d2: ::Numeric, e2: ::Numeric, f2: ::Numeric).void }
+  def xy_scaling_multiply!(a2, b2, c2, d2, e2, f2); end
 
-      sig { params(args: T.untyped).void }
-      def show_text_with_positioning(*args); end
+  sig { params(a2: ::Numeric, b2: ::Numeric, c2: ::Numeric, d2: ::Numeric, e2: ::Numeric, f2: ::Numeric).void }
+  def xy_scaling_multiply_reversed!(a2, b2, c2, d2, e2, f2); end
+end
 
-      sig { params(args: T.untyped).void }
-      def move_to_next_line_and_show_text(*args); end
+class PDF::Reader::TypeCheck
+  class << self
+    sig { params(obj: T.untyped).returns(::Integer) }
+    def cast_to_int!(obj); end
 
-      sig { params(args: T.untyped).void }
-      def set_spacing_next_line_show_text(*args); end
+    sig { params(obj: T.untyped).returns(::Numeric) }
+    def cast_to_numeric!(obj); end
 
-      sig { params(args: T.untyped).void }
-      def invoke_xobject(*args); end
+    sig { params(obj: T.untyped).returns(T::Hash[::Symbol, T.untyped]) }
+    def cast_to_pdf_dict!(obj); end
 
-      sig { params(args: T.untyped).void }
-      def begin_inline_image(*args); end
+    sig { params(obj: T.untyped).returns(T::Hash[::Symbol, ::PDF::Reader::Stream]) }
+    def cast_to_pdf_dict_with_stream_values!(obj); end
 
-      sig { params(args: T.untyped).void }
-      def begin_inline_image_data(*args); end
+    sig { params(string: T.untyped).returns(::String) }
+    def cast_to_string!(string); end
 
-      sig { params(args: T.untyped).void }
-      def end_inline_image(*args); end
+    sig { params(obj: T.untyped).returns(::Symbol) }
+    def cast_to_symbol(obj); end
 
-      sig { params(meth: T.untyped).returns(T::Boolean) }
-      def respond_to?(meth); end
+    sig { params(obj: T.untyped).returns(::Symbol) }
+    def cast_to_symbol!(obj); end
+  end
+end
 
-      sig { params(methodname: Symbol, args: T.untyped).void }
-      def method_missing(methodname, *args); end
+class PDF::Reader::UnimplementedSecurityHandler
+  sig { params(buf: ::String, ref: ::PDF::Reader::Reference).returns(::String) }
+  def decrypt(buf, ref); end
 
-      sig { params(methodname: T.untyped, args: T.untyped).void }
-      def call_wrapped(methodname, *args); end
-    end
+  class << self
+    sig { params(encrypt: T::Hash[::Symbol, T.untyped]).returns(T::Boolean) }
+    def supports?(encrypt); end
+  end
+end
 
-    class UnimplementedSecurityHandler
-      sig { params(encrypt: T.untyped).returns(T.untyped) }
-      def self.supports?(encrypt); end
+class PDF::Reader::UnsupportedFeatureError < ::RuntimeError; end
 
-      sig { params(buf: T.untyped, ref: T.untyped).returns(T.untyped) }
-      def decrypt(buf, ref); end
-    end
+class PDF::Reader::ValidatingReceiver
+  sig { params(wrapped: T.untyped).void }
+  def initialize(wrapped); end
 
-    class XRef
-      include Enumerable
+  sig { params(args: T.untyped).void }
+  def begin_inline_image(*args); end
 
-      sig { returns(T.untyped) }
-      attr_reader :trailer
+  sig { params(args: T.untyped).void }
+  def begin_inline_image_data(*args); end
 
-      sig { params(io: T.untyped).void }
-      def initialize(io); end
+  sig { params(args: T.untyped).void }
+  def begin_text_object(*args); end
 
-      sig { returns(T.untyped) }
-      def size; end
+  sig { params(args: T.untyped).void }
+  def concatenate_matrix(*args); end
 
-      sig { params(ref: T.untyped).returns(T.untyped) }
-      def [](ref); end
+  sig { params(args: T.untyped).void }
+  def end_inline_image(*args); end
 
-      sig { params(block: T.untyped).returns(T.untyped) }
-      def each(&block); end
+  sig { params(args: T.untyped).void }
+  def end_text_object(*args); end
 
-      sig { params(offset: T.untyped).returns(T.untyped) }
-      def load_offsets(offset = nil); end
+  sig { params(args: T.untyped).void }
+  def invoke_xobject(*args); end
 
-      sig { params(buf: T.untyped).returns(T.untyped) }
-      def load_xref_table(buf); end
+  sig { params(methodname: ::Symbol, args: T.untyped).void }
+  def method_missing(methodname, *args); end
 
-      sig { params(stream: T.untyped).returns(T.untyped) }
-      def load_xref_stream(stream); end
+  sig { params(args: T.untyped).void }
+  def move_text_position(*args); end
 
-      sig { params(bytes: T.untyped).returns(T.untyped) }
-      def unpack_bytes(bytes); end
+  sig { params(args: T.untyped).void }
+  def move_text_position_and_set_leading(*args); end
 
-      sig { params(offset: T.untyped).returns(T.untyped) }
-      def new_buffer(offset = 0); end
+  sig { params(args: T.untyped).void }
+  def move_to_next_line_and_show_text(*args); end
 
-      sig { params(id: T.untyped, gen: T.untyped, offset: T.untyped).returns(T.untyped) }
-      def store(id, gen, offset); end
+  sig { params(args: T.untyped).void }
+  def move_to_start_of_next_line(*args); end
 
-      sig { params(io: T.untyped).returns(T.untyped) }
-      def calc_junk_offset(io); end
-    end
+  sig { params(page: ::PDF::Reader::Page).void }
+  def page=(page); end
 
-    class ZeroWidthRunsFilter
-      sig { params(runs: T::Array[PDF::Reader::TextRun]).returns(T::Array[PDF::Reader::TextRun]) }
-      def self.exclude_zero_width_runs(runs); end
-    end
+  sig { params(meth: T.untyped).returns(T::Boolean) }
+  def respond_to?(meth); end
 
-    module Filter
-      sig { params(name: Symbol, options: T::Hash[T.untyped, T.untyped]).returns(T.untyped) }
-      def self.with(name, options = {}); end
-
-      class Ascii85
-        sig { params(options: T::Hash[T.untyped, T.untyped]).void }
-        def initialize(options = {})
-          @options = T.let(T.unsafe(nil), T::Hash[T.untyped, T.untyped])
-        end
-
-        sig { params(data: String).returns(String) }
-        def filter(data); end
-      end
-
-      class AsciiHex
-        sig { params(options: T::Hash[T.untyped, T.untyped]).void }
-        def initialize(options = {})
-          @options = T.let(T.unsafe(nil), T::Hash[T.untyped, T.untyped])
-        end
-
-        sig { params(data: String).returns(String) }
-        def filter(data); end
-      end
-
-      class Depredict
-        sig { params(options: T::Hash[T.untyped, T.untyped]).void }
-        def initialize(options = {}); end
-
-        sig { params(data: String).returns(String) }
-        def filter(data); end
-
-        sig { params(data: T.untyped).returns(T.untyped) }
-        def tiff_depredict(data); end
-
-        sig { params(data: T.untyped).returns(T.untyped) }
-        def png_depredict(data); end
-      end
-
-      class Flate
-        ZLIB_AUTO_DETECT_ZLIB_OR_GZIP = 47
-        ZLIB_RAW_DEFLATE = -15
-
-        sig { params(options: T::Hash[T.untyped, T.untyped]).void }
-        def initialize(options = {})
-          @options = T.let(T.unsafe(nil), T::Hash[T.untyped, T.untyped])
-        end
-
-        sig { params(data: String).returns(String) }
-        def filter(data); end
-
-        sig { params(data: T.untyped).returns(T.untyped) }
-        def zlib_inflate(data); end
-      end
-
-      class Lzw
-        sig { params(options: T::Hash[T.untyped, T.untyped]).void }
-        def initialize(options = {})
-          @options = T.let(T.unsafe(nil), T::Hash[T.untyped, T.untyped])
-        end
-
-        sig { params(data: String).returns(String) }
-        def filter(data); end
-      end
-
-      class Null
-        sig { params(options: T::Hash[T.untyped, T.untyped]).void }
-        def initialize(options = {})
-          @options = T.let(T.unsafe(nil), T::Hash[T.untyped, T.untyped])
-        end
-
-        sig { params(data: T.untyped).returns(T.untyped) }
-        def filter(data); end
-      end
-
-      class RunLength
-        sig { params(options: T::Hash[T.untyped, T.untyped]).void }
-        def initialize(options = {})
-          @options = T.let(T.unsafe(nil), T::Hash[T.untyped, T.untyped])
-        end
-
-        sig { params(data: String).returns(String) }
-        def filter(data); end
-      end
-    end
+  sig { params(args: T.untyped).void }
+  def restore_graphics_state(*args); end
 
-    module WidthCalculator
-      class BuiltIn
-        BUILTINS = [
-        :Courier, :"Courier-Bold", :"Courier-BoldOblique", :"Courier-Oblique",
-        :Helvetica, :"Helvetica-Bold", :"Helvetica-BoldOblique", :"Helvetica-Oblique",
-        :Symbol,
-        :"Times-Roman", :"Times-Bold", :"Times-BoldItalic", :"Times-Italic",
-        :ZapfDingbats
-      ]
+  sig { params(args: T.untyped).void }
+  def save_graphics_state(*args); end
 
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+  sig { params(args: T.untyped).void }
+  def set_character_spacing(*args); end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
-        def glyph_width(code_point); end
+  sig { params(args: T.untyped).void }
+  def set_horizontal_text_scaling(*args); end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
-        def control_character?(code_point); end
+  sig { params(args: T.untyped).void }
+  def set_spacing_next_line_show_text(*args); end
 
-        sig { params(font_name: T.untyped).returns(T.untyped) }
-        def extract_basefont(font_name); end
-      end
+  sig { params(args: T.untyped).void }
+  def set_text_font_and_size(*args); end
 
-      class Composite
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+  sig { params(args: T.untyped).void }
+  def set_text_leading(*args); end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
-        def glyph_width(code_point); end
-      end
+  sig { params(args: T.untyped).void }
+  def set_text_matrix_and_text_line_matrix(*args); end
 
-      class TrueType
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+  sig { params(args: T.untyped).void }
+  def set_text_rendering_mode(*args); end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
-        def glyph_width(code_point); end
+  sig { params(args: T.untyped).void }
+  def set_text_rise(*args); end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
-        def glyph_width_from_font(code_point); end
+  sig { params(args: T.untyped).void }
+  def set_word_spacing(*args); end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
-        def glyph_width_from_descriptor(code_point); end
-      end
+  sig { params(args: T.untyped).void }
+  def show_text(*args); end
 
-      class TypeOneOrThree
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+  sig { params(args: T.untyped).void }
+  def show_text_with_positioning(*args); end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
-        def glyph_width(code_point); end
-      end
+  private
 
-      class TypeZero
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+  sig { params(methodname: T.untyped, args: T.untyped).void }
+  def call_wrapped(methodname, *args); end
+end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
-        def glyph_width(code_point); end
-      end
-    end
+module PDF::Reader::WidthCalculator; end
+
+class PDF::Reader::WidthCalculator::BuiltIn
+  sig { params(font: ::PDF::Reader::Font).void }
+  def initialize(font); end
+
+  sig { params(code_point: T.nilable(::Integer)).returns(::Numeric) }
+  def glyph_width(code_point); end
+
+  private
+
+  sig { params(code_point: ::Integer).returns(T::Boolean) }
+  def control_character?(code_point); end
+
+  sig { params(font_name: T.nilable(::Symbol)).returns(::String) }
+  def extract_basefont(font_name); end
+end
+
+PDF::Reader::WidthCalculator::BuiltIn::BUILTINS = T.let(T.unsafe(nil), Array)
+
+class PDF::Reader::WidthCalculator::Composite
+  sig { params(font: ::PDF::Reader::Font).void }
+  def initialize(font); end
+
+  sig { params(code_point: T.nilable(::Integer)).returns(::Numeric) }
+  def glyph_width(code_point); end
+end
+
+class PDF::Reader::WidthCalculator::TrueType
+  sig { params(font: ::PDF::Reader::Font).void }
+  def initialize(font); end
+
+  sig { params(code_point: T.nilable(::Integer)).returns(::Numeric) }
+  def glyph_width(code_point); end
+
+  private
+
+  sig { params(code_point: ::Integer).returns(T.nilable(::Numeric)) }
+  def glyph_width_from_descriptor(code_point); end
+
+  sig { params(code_point: ::Integer).returns(T.nilable(::Numeric)) }
+  def glyph_width_from_font(code_point); end
+end
+
+class PDF::Reader::WidthCalculator::TypeOneOrThree
+  sig { params(font: ::PDF::Reader::Font).void }
+  def initialize(font); end
+
+  sig { params(code_point: T.nilable(::Integer)).returns(::Numeric) }
+  def glyph_width(code_point); end
+end
+
+class PDF::Reader::WidthCalculator::TypeZero
+  sig { params(font: ::PDF::Reader::Font).void }
+  def initialize(font); end
+
+  sig { params(code_point: T.nilable(::Integer)).returns(::Numeric) }
+  def glyph_width(code_point); end
+end
+
+class PDF::Reader::XRef
+  extend T::Generic
+  include ::Enumerable
+
+  Elem = type_member
+
+  sig { params(io: T.any(::IO, ::StringIO, ::Tempfile)).void }
+  def initialize(io); end
+
+  sig { params(ref: T.untyped).returns(T.untyped) }
+  def [](ref); end
+
+  sig { override.params(block: T.proc.params(arg0: ::PDF::Reader::Reference).returns(T.untyped)).void }
+  def each(&block); end
+
+  sig { returns(T.untyped) }
+  def size; end
+
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def trailer; end
+
+  private
+
+  sig { params(io: T.any(::IO, ::StringIO, ::Tempfile)).returns(T.nilable(::Integer)) }
+  def calc_junk_offset(io); end
+
+  sig { params(offset: T.nilable(::Integer)).returns(T::Hash[::Symbol, T.untyped]) }
+  def load_offsets(offset = T.unsafe(nil)); end
+
+  sig { params(stream: ::PDF::Reader::Stream).returns(T::Hash[::Symbol, T.untyped]) }
+  def load_xref_stream(stream); end
+
+  sig { params(buf: ::PDF::Reader::Buffer).returns(T::Hash[::Symbol, T.untyped]) }
+  def load_xref_table(buf); end
+
+  sig { params(offset: ::Integer).returns(::PDF::Reader::Buffer) }
+  def new_buffer(offset = T.unsafe(nil)); end
+
+  sig do
+    params(
+      id: ::Integer,
+      gen: ::Integer,
+      offset: T.any(::Integer, ::PDF::Reader::Reference)
+    ).returns(T.any(::Integer, ::PDF::Reader::Reference))
+  end
+  def store(id, gen, offset); end
+
+  sig { params(bytes: T.nilable(::String)).returns(::Integer) }
+  def unpack_bytes(bytes); end
+end
+
+class PDF::Reader::ZeroWidthRunsFilter
+  class << self
+    sig { params(runs: T::Array[::PDF::Reader::TextRun]).returns(T::Array[::PDF::Reader::TextRun]) }
+    def exclude_zero_width_runs(runs); end
   end
 end