pdf-reader 2.9.2 → 2.11.0

data/rbi/pdf-reader.rbi

@@ -1,16 +1,21 @@
 # typed: strong
 module PDF
   class Reader
-    sig { returns(T.untyped) }
+    sig { returns(PDF::Reader::ObjectHash) }
     attr_reader :objects
 
-    sig { params(input: T.any(String, IO), opts: T::Hash[T.untyped, T.untyped]).void }
-    def initialize(input, opts = {}); end
+    sig { params(input: T.any(String, Tempfile, IO), opts: T::Hash[T.untyped, T.untyped]).void }
+    def initialize(input, opts = {})
+      @cache = T.let(T.unsafe(nil), PDF::Reader::ObjectCache)
+      @objects = T.let(T.unsafe(nil), PDF::Reader::ObjectHash)
+      @page_count = T.let(T.unsafe(nil), T.nilable(Integer))
+      @root = T.let(T.unsafe(nil), T.nilable(T.nilable(T::Hash[Symbol, T.untyped])))
+    end
 
     sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
     def info; end
 
-    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    sig { returns(T.nilable(String)) }
     def metadata; end
 
     sig { returns(Integer) }
@@ -19,7 +24,7 @@ module PDF
     sig { returns(Float) }
     def pdf_version; 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) }
+    sig { params(input: T.any(String, Tempfile, 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(T::Array[PDF::Reader::Page]) }
@@ -70,28 +75,29 @@ module PDF
     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
+      TOKEN_WHITESPACE = T.let(T.unsafe(nil), T::Array[Integer])
+      TOKEN_DELIMITER = T.let(T.unsafe(nil), T::Array[Integer])
+      LEFT_PAREN = T.let(T.unsafe(nil), String)
+      LESS_THAN = T.let(T.unsafe(nil), String)
+      STREAM = T.let(T.unsafe(nil), String)
+      ID = T.let(T.unsafe(nil), String)
+      FWD_SLASH = T.let(T.unsafe(nil), String)
+      NULL_BYTE = T.let(T.unsafe(nil), String)
+      CR = T.let(T.unsafe(nil), String)
+      LF = T.let(T.unsafe(nil), String)
+      CRLF = T.let(T.unsafe(nil), String)
+      WHITE_SPACE = T.let(T.unsafe(nil), T::Array[String])
+      TRAILING_BYTECOUNT = T.let(T.unsafe(nil), Integer)
+      DIGITS_ONLY = T.let(T.unsafe(nil), Regexp)
 
       sig { returns(Integer) }
       attr_reader :pos
 
-      sig { params(io: T.any(StringIO, File), opts: T::Hash[Symbol, T.untyped]).void }
+      sig { params(io: T.any(StringIO, Tempfile, IO), 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))
+        @io = T.let(T.unsafe(nil), T.any(StringIO, Tempfile, IO))
         @in_content_stream = T.let(T.unsafe(nil), T::Boolean)
       end
 
@@ -145,31 +151,23 @@ module PDF
     end
 
     class CidWidths
-      sig { params(default: T.untyped, array: T.untyped).void }
-      def initialize(default, array); end
+      sig { params(default: Numeric, array: T::Array[Numeric]).void }
+      def initialize(default, array)
+        @widths = T.let(T.unsafe(nil), T::Hash[Numeric, Numeric])
+      end
 
-      sig { params(default: T.untyped, array: T.untyped).returns(T.untyped) }
+      sig { params(default: Numeric, array: T::Array[Numeric]).returns(T::Hash[Numeric, Numeric]) }
       def parse_array(default, array); end
 
-      sig { params(first: T.untyped, widths: T.untyped).returns(T.untyped) }
+      sig { params(first: Integer, widths: T::Array[Numeric]).returns(T::Hash[Numeric, Numeric]) }
       def parse_first_form(first, widths); end
 
-      sig { params(first: T.untyped, final: T.untyped, width: T.untyped).returns(T.untyped) }
+      sig { params(first: Integer, final: Integer, width: Numeric).returns(T::Hash[Numeric, Numeric]) }
       def parse_second_form(first, final, width); end
     end
 
     class CMap
-      CMAP_KEYWORDS = {
-      "begincodespacerange" => 1,
-      "endcodespacerange" => 1,
-      "beginbfchar" => 1,
-      "endbfchar" => 1,
-      "beginbfrange" => 1,
-      "endbfrange" => 1,
-      "begin" => 1,
-      "begincmap" => 1,
-      "def" => 1
-    }
+      CMAP_KEYWORDS = T.let(T.unsafe(nil), T::Hash[String, Symbol])
 
       sig { returns(T.untyped) }
       attr_reader :map
@@ -208,20 +206,27 @@ module PDF
     end
 
     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
+      CONTROL_CHARS = T.let(T.unsafe(nil), T::Array[Integer])
+      UNKNOWN_CHAR = T.let(T.unsafe(nil), Integer)
 
-      sig { returns(T.untyped) }
+      sig { returns(String) }
       attr_reader :unpack
 
       sig { params(enc: T.untyped).void }
-      def initialize(enc); end
+      def initialize(enc)
+        @mapping = T.let(T.unsafe(nil), T::Hash[Integer, Integer])
+        @unpack = T.let(T.unsafe(nil), String)
+        @enc_name = T.let(T.unsafe(nil), Symbol)
+        @string_cache = T.let(T.unsafe(nil), T::Hash[Integer, String])
+        @map_file = T.let(T.unsafe(nil), T.nilable(String))
+        @differences = T.let(T.unsafe(nil), T.nilable(T::Hash[Integer, Integer]))
+        @glyphlist = T.let(T.unsafe(nil), T.nilable(PDF::Reader::GlyphHash))
+      end
 
-      sig { params(diff: T.untyped).returns(T.untyped) }
+      sig { params(diff: T::Array[T.any(Integer, Symbol)]).returns(T::Hash[Integer, Integer]) }
       def differences=(diff); end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Integer, Integer]) }
       def differences; end
 
       sig { params(str: String).returns(String) }
@@ -233,31 +238,31 @@ module PDF
       sig { params(glyph_code: Integer).returns(T::Array[Symbol]) }
       def int_to_name(glyph_code); end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Integer, Integer]) }
       def default_mapping; end
 
-      sig { params(glyph_code: T.untyped).returns(T.untyped) }
+      sig { params(glyph_code: Integer).returns(String) }
       def internal_int_to_utf8_string(glyph_code); end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Boolean) }
       def utf8_conversion_impossible?; end
 
-      sig { params(times: T.untyped).returns(T.untyped) }
+      sig { params(times: Integer).returns(String) }
       def little_boxes(times); end
 
-      sig { params(str: T.untyped).returns(T.untyped) }
+      sig { params(str: String).returns(String) }
       def convert_to_utf8(str); end
 
-      sig { params(enc: T.untyped).returns(T.untyped) }
+      sig { params(enc: T.untyped).returns(String) }
       def get_unpack(enc); end
 
-      sig { params(enc: T.untyped).returns(T.untyped) }
+      sig { params(enc: T.untyped).returns(T.nilable(String)) }
       def get_mapping_file(enc); end
 
-      sig { returns(T.untyped) }
+      sig { returns(PDF::Reader::GlyphHash) }
       def glyphlist; end
 
-      sig { params(file: T.untyped).returns(T.untyped) }
+      sig { params(file: String).void }
       def load_mapping(file); end
     end
 
@@ -279,9 +284,6 @@ module PDF
 
       sig { params(object: Object, name: String).void }
 		  def self.validate_not_nil(object, name); end
-
-      sig { params(object: Object, name: String).void }
-		  def self.validate_not_nil_as_malformed(object, name); end
     end
 
     class MalformedPDFError < RuntimeError
@@ -300,138 +302,146 @@ module PDF
     end
 
     class Font
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Symbol)) }
       attr_accessor :subtype
 
-      sig { returns(T.untyped) }
+      sig { returns(PDF::Reader::Encoding) }
       attr_accessor :encoding
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[PDF::Reader::Font]) }
       attr_accessor :descendantfonts
 
-      sig { returns(T.untyped) }
+      sig { returns(PDF::Reader::CMap) }
       attr_accessor :tounicode
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[Integer]) }
       attr_reader :widths
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Integer)) }
       attr_reader :first_char
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Integer)) }
       attr_reader :last_char
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Symbol)) }
       attr_reader :basefont
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(PDF::Reader::FontDescriptor)) }
       attr_reader :font_descriptor
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[Numeric]) }
       attr_reader :cid_widths
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :cid_default_width
 
-      sig { params(ohash: T.untyped, obj: T.untyped).void }
+      sig { params(ohash: PDF::Reader::ObjectHash, obj: T::Hash[Symbol, T.untyped]).void }
       def initialize(ohash, obj); end
 
-      sig { params(params: T.untyped).returns(T.untyped) }
+      sig { params(params: T.any(Integer, String, T::Array[T.untyped])).returns(String) }
       def to_utf8(params); end
 
-      sig { params(data: T.untyped).returns(T.untyped) }
+      sig { params(data: String).returns(T::Array[T.nilable(T.any(Numeric, String))]) }
       def unpack(data); end
 
-      sig { params(code_point: T.untyped).returns(T.untyped) }
+      sig { params(code_point: T.any(String, Integer)).returns(T.untyped) }
       def glyph_width(code_point); end
 
-      sig { params(font_name: T.untyped).returns(T.untyped) }
+      sig { params(font_name: Symbol).returns(PDF::Reader::Encoding) }
       def default_encoding(font_name); end
 
-      sig { returns(T.untyped) }
+      sig {
+        returns(
+          T.any(
+            PDF::Reader::WidthCalculator::BuiltIn,
+            PDF::Reader::WidthCalculator::Composite,
+            PDF::Reader::WidthCalculator::TrueType,
+            PDF::Reader::WidthCalculator::TypeOneOrThree,
+            PDF::Reader::WidthCalculator::TypeZero,
+          )
+        )
+      }
       def build_width_calculator; end
 
-      sig { params(obj: T.untyped).returns(T.untyped) }
+      sig { params(obj: T.untyped).void }
       def extract_base_info(obj); end
 
-      sig { params(obj: T.untyped).returns(T.untyped) }
+      sig { params(obj: T.untyped).void }
       def extract_descriptor(obj); end
 
-      sig { params(obj: T.untyped).returns(T.untyped) }
+      sig { params(obj: T.untyped).void }
       def extract_descendants(obj); end
 
-      sig { params(params: T.untyped).returns(T.untyped) }
+      sig { params(params: T.any(Integer, String, T::Array[T.untyped])).returns(String) }
       def to_utf8_via_cmap(params); end
 
-      sig { params(params: T.untyped).returns(T.untyped) }
+      sig { params(params: T.any(Integer, String, T::Array[T.untyped])).returns(String) }
       def to_utf8_via_encoding(params); end
     end
 
     class FontDescriptor
-      sig { returns(T.untyped) }
+      sig { returns(String) }
       attr_reader :font_name
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(String)) }
       attr_reader :font_family
 
-      sig { returns(T.untyped) }
+      sig { returns(Symbol) }
       attr_reader :font_stretch
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :font_weight
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[Numeric]) }
       attr_reader :font_bounding_box
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :cap_height
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :ascent
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :descent
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :leading
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :avg_width
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :max_width
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :missing_width
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Numeric)) }
       attr_reader :italic_angle
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Numeric)) }
       attr_reader :stem_v
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Numeric)) }
       attr_reader :x_height
 
-      sig { returns(T.untyped) }
+      sig { returns(Integer) }
       attr_reader :font_flags
 
       sig { params(ohash: PDF::Reader::ObjectHash, fd_hash: T::Hash[T.untyped, T.untyped]).void }
       def initialize(ohash, fd_hash); end
 
-      sig { params(char_code: T.untyped).returns(T.untyped) }
+      sig { params(char_code: Integer).returns(Numeric) }
       def glyph_width(char_code); end
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       def glyph_to_pdf_scale_factor; end
 
-      sig { returns(T.untyped) }
+      sig { returns(TTFunk::File) }
       def ttf_program_stream; end
     end
 
     class FormXObject
-      include ResourceMethods
-
       sig { returns(T.untyped) }
       attr_reader :xobject
 
@@ -467,16 +477,22 @@ module PDF
     end
 
     class GlyphHash
+      @@by_name_cache = T.let(T.unsafe(nil), T.nilable(T::Hash[Symbol, Integer]))
+      @@by_codepoint_cache = T.let(T.unsafe(nil), T.nilable(T::Hash[Integer, T::Array[Symbol]]))
+
       sig { void }
-      def initialize; end
+      def initialize
+        @by_name = T.let(T.unsafe(nil), T::Hash[Symbol, Integer])
+        @by_codepoint = T.let(T.unsafe(nil), T::Hash[Integer, T::Array[Symbol]])
+      end
 
-      sig { params(name: T.untyped).returns(T.untyped) }
+      sig { params(name: T.nilable(Symbol)).returns(T.nilable(Integer)) }
       def name_to_unicode(name); end
 
-      sig { params(codepoint: T.untyped).returns(T.untyped) }
+      sig { params(codepoint: T.nilable(Integer)).returns(T::Array[Symbol]) }
       def unicode_to_name(codepoint); end
 
-      sig { returns(T.untyped) }
+      sig { returns([T::Hash[Symbol, Integer], T::Hash[Integer, T::Array[Symbol]]]) }
       def load_adobe_glyph_mapping; end
     end
 
@@ -517,34 +533,43 @@ module PDF
       CODE_CLEAR_TABLE = 256
 
       class BitStream
-        sig { params(data: T.untyped, bits_in_chunk: T.untyped).void }
-        def initialize(data, bits_in_chunk); end
+        sig { params(data: String, bits_in_chunk: Integer).void }
+        def initialize(data, bits_in_chunk)
+          @data = T.let(T.unsafe(nil), String)
+          @bits_in_chunk = T.let(T.unsafe(nil), Integer)
+          @current_pos = T.let(T.unsafe(nil), Integer)
+          @bits_left_in_byte = T.let(T.unsafe(nil), Integer)
 
-        sig { params(bits_in_chunk: T.untyped).returns(T.untyped) }
+        end
+
+        sig { params(bits_in_chunk: Integer).void }
         def set_bits_in_chunk(bits_in_chunk); end
 
-        sig { returns(T.untyped) }
+        sig { returns(Integer) }
         def read; end
       end
 
-      class StringTable < Hash
-        sig { returns(T.untyped) }
+      class StringTable
+        sig { returns(Integer) }
         attr_reader :string_table_pos
 
         sig { void }
-        def initialize; end
+        def initialize
+          @data = T.let(T.unsafe(nil), T::Hash[Integer, String])
+          @string_table_pos = T.let(T.unsafe(nil), Integer)
+        end
 
-        sig { params(key: T.untyped).returns(T.untyped) }
+        sig { params(key: Integer).returns(T.nilable(String)) }
         def [](key); end
 
-        sig { params(string: T.untyped).returns(T.untyped) }
+        sig { params(string: String).void }
         def add(string); end
       end
 
-      sig { params(data: T.untyped).returns(T.untyped) }
+      sig { params(data: String).returns(String) }
       def self.decode(data); end
 
-      sig { params(string_table: T.untyped, some_code: T.untyped, other_code: T.untyped).returns(T.untyped) }
+      sig { params(string_table: PDF::Reader::LZW::StringTable, some_code: T.nilable(Integer), other_code: T.nilable(Integer)).returns(String) }
       def self.create_new_string(string_table, some_code, other_code); end
     end
 
@@ -617,25 +642,45 @@ module PDF
       sig { returns(T.untyped) }
       attr_accessor :default
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       attr_reader :trailer
 
-      sig { returns(T.untyped) }
+      sig { returns(Float) }
       attr_reader :pdf_version
 
-      sig { returns(T.untyped) }
+      sig { returns(
+        T.any(
+          PDF::Reader::NullSecurityHandler,
+          PDF::Reader::AesV2SecurityHandler,
+          PDF::Reader::AesV3SecurityHandler,
+          PDF::Reader::Rc4SecurityHandler,
+      )) }
       attr_reader :sec_handler
 
-      sig { params(input: T.untyped, opts: T.untyped).void }
-      def initialize(input, opts = {}); end
+      sig { params(input: T.any(IO, Tempfile, StringIO, String), opts: T::Hash[Symbol, T.untyped]).void }
+      def initialize(input, opts = {})
+        @io = T.let(T.unsafe(nil), T.any(IO, Tempfile, StringIO))
+        @xref = T.let(T.unsafe(nil), PDF::Reader::XRef)
+        @pdf_version = T.let(T.unsafe(nil), Float)
+        @trailer = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped])
+        @cache = T.let(T.unsafe(nil), PDF::Reader::ObjectCache)
+        @sec_handler = T.let(T.unsafe(nil), T.any(
+          PDF::Reader::NullSecurityHandler,
+          PDF::Reader::AesV2SecurityHandler,
+          PDF::Reader::AesV3SecurityHandler,
+          PDF::Reader::Rc4SecurityHandler,
+        ))
+        @page_references = T.let(T.unsafe(nil), T.nilable(T::Array[T.any(PDF::Reader::Reference, T::Hash[Symbol, T.untyped])]))
+        @object_streams = T.let(T.unsafe(nil), T.nilable(T::Hash[PDF::Reader::Reference, PDF::Reader::ObjectStream]))
+      end
 
-      sig { params(ref: T.untyped).returns(T.untyped) }
+      sig { params(ref: T.any(Integer, PDF::Reader::Reference)).returns(T.nilable(Symbol)) }
       def obj_type(ref); end
 
-      sig { params(ref: T.untyped).returns(T.untyped) }
+      sig { params(ref: T.any(Integer, PDF::Reader::Reference)).returns(T::Boolean) }
       def stream?(ref); end
 
-      sig { params(key: T.untyped).returns(T.untyped) }
+      sig { params(key: T.any(Integer, PDF::Reader::Reference)).returns(T.untyped) }
       def [](key); end
 
       sig { params(key: T.untyped).returns(T.untyped) }
@@ -647,7 +692,7 @@ module PDF
       sig { params(key: T.untyped).returns(T.nilable(T::Array[Numeric])) }
       def deref_array_of_numbers(key); end
 
-      sig { params(key: T.untyped).returns(T.nilable(T:Hash[Symbol, T.untyped])) }
+      sig { params(key: T.untyped).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def deref_hash(key); end
 
       sig { params(key: T.untyped).returns(T.nilable(Symbol)) }
@@ -674,10 +719,10 @@ module PDF
       sig { params(key: T.untyped).returns(T.untyped) }
       def deref!(key); end
 
-      sig { params(key: T.untyped).returns(T::Array[T.untyped]) }
+      sig { params(key: T.untyped).returns(T.nilable(T::Array[T.untyped])) }
       def deref_array!(key); end
 
-      sig { params(key: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+      sig { params(key: T.untyped).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def deref_hash!(key); end
 
       sig { params(key: T.untyped, local_default: T.untyped).returns(T.untyped) }
@@ -719,7 +764,7 @@ module PDF
       sig { returns(T.untyped) }
       def to_a; end
 
-      sig { returns(T::Array[PDF::Reader::Reference]) }
+      sig { returns(T::Array[T.any(PDF::Reader::Reference, T::Hash[Symbol, T.untyped])]) }
       def page_references; end
 
       sig { returns(T::Boolean) }
@@ -749,41 +794,50 @@ module PDF
       sig { returns(T.untyped) }
       def object_streams; end
 
-      sig { params(obj: T::Hash[T.untyped, T.untyped]).returns(T::Array[T::Hash[T.untyped, T.untyped]]) }
+      sig { 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])]) }
       def get_page_objects(obj); end
 
       sig { returns(Float) }
       def read_version; end
 
-      sig { params(input: T.untyped).returns(IO) }
+      sig { params(input: T.any(IO, Tempfile, StringIO, String)).returns(T.any(IO, Tempfile, StringIO)) }
       def extract_io_from(input); end
 
-      sig { params(input: T.untyped).returns(T.untyped) }
+      sig { params(input: String).returns(String) }
       def read_as_binary(input); end
     end
 
     class ObjectStream
-      sig { params(stream: T.untyped).void }
-      def initialize(stream); end
+      sig { params(stream: PDF::Reader::Stream).void }
+      def initialize(stream)
+        @dict = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped])
+        @data = T.let(T.unsafe(nil), String)
+        @offsets = T.let(T.unsafe(nil), T.nilable(T::Hash[Integer, Integer]))
+        @buffer = T.let(T.unsafe(nil), T.nilable(PDF::Reader::Buffer))
+      end
 
-      sig { params(objid: T.untyped).returns(T.untyped) }
+      sig {
+        params(objid: Integer).returns(
+          T.any(PDF::Reader::Reference, PDF::Reader::Token, Numeric, String, Symbol, T::Array[T.untyped], T::Hash[T.untyped, T.untyped], NilClass)
+        )
+      }
       def [](objid); end
 
-      sig { returns(T.untyped) }
+      sig { returns(Integer) }
       def size; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Integer, Integer]) }
       def offsets; end
 
-      sig { returns(T.untyped) }
+      sig { returns(Integer) }
       def first; end
 
-      sig { returns(T.untyped) }
+      sig { returns(PDF::Reader::Buffer) }
       def buffer; end
     end
 
     class OverlappingRunsFilter
-      OVERLAPPING_THRESHOLD = 0.5
+      OVERLAPPING_THRESHOLD = T.let(T.unsafe(nil), Float)
 
       sig { params(runs: T::Array[PDF::Reader::TextRun]).returns(T::Array[PDF::Reader::TextRun]) }
       def self.exclude_redundant_runs(runs); end
@@ -792,6 +846,11 @@ module PDF
       def self.detect_intersection(sweep_line_status, event_point); end
     end
 
+    class NoTextFilter
+      sig { params(runs: T::Array[PDF::Reader::TextRun]).returns(T::Array[PDF::Reader::TextRun]) }
+      def self.exclude_empty_strings(runs); end
+    end
+
     class EventPoint
       sig { returns(Numeric) }
       attr_reader :x
@@ -800,26 +859,35 @@ module PDF
       attr_reader :run
 
       sig { params(x: Numeric, run: PDF::Reader::TextRun).void }
-      def initialize(x, run); end
+      def initialize(x, run)
+        @x = T.let(T.unsafe(nil), Numeric)
+        @run = T.let(T.unsafe(nil), PDF::Reader::TextRun)
+      end
 
       sig { returns(T::Boolean) }
       def start?; end
     end
 
     class Page
-      include ResourceMethods
-
       sig { returns(PDF::Reader::ObjectHash) }
       attr_reader :objects
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       attr_reader :page_object
 
-      sig { returns(T.untyped) }
+      sig { returns(T.any(PDF::Reader::ObjectCache, T::Hash[T.untyped, T.untyped])) }
       attr_reader :cache
 
       sig { params(objects: PDF::Reader::ObjectHash, pagenum: Integer, options: T::Hash[Symbol, T.untyped]).void }
-      def initialize(objects, pagenum, options = {}); end
+      def initialize(objects, pagenum, options = {})
+        @objects = T.let(T.unsafe(nil), PDF::Reader::ObjectHash)
+        @pagenum = T.let(T.unsafe(nil), Integer)
+        @page_object = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped])
+        @cache = T.let(T.unsafe(nil), T.any(PDF::Reader::ObjectCache, T::Hash[T.untyped, T.untyped]))
+        @attributes = T.let(T.unsafe(nil), T.nilable(T::Hash[Symbol, T.untyped]))
+        @root = T.let(T.unsafe(nil), T.nilable(T::Hash[Symbol, T.untyped]))
+        @resources = T.let(T.unsafe(nil), T.nilable(PDF::Reader::Resources))
+      end
 
       sig { returns(Integer) }
       def number; end
@@ -869,10 +937,10 @@ module PDF
       sig { returns(PDF::Reader::Resources) }
       def resources; end
 
-      sig { params(receivers: T.untyped, instructions: T.untyped).returns(T.untyped) }
+      sig { params(receivers: T::Array[T.untyped], instructions: String).void }
       def content_stream(receivers, instructions); end
 
-      sig { params(receivers: T.untyped, name: T.untyped, params: T.untyped).returns(T.untyped) }
+      sig { params(receivers: T::Array[Object], name: Symbol, params: T::Array[T.untyped]).void }
       def callback(receivers, name, params = []); end
 
       sig { returns(T.untyped) }
@@ -881,15 +949,26 @@ module PDF
       sig { params(origin: T.untyped).returns(T.untyped) }
       def ancestors(origin = @page_object[:Parent]); end
 
-      sig { params(obj: T::Hash[T.untyped, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+      sig { params(obj: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
       def select_inheritable(obj); end
     end
 
     class PageLayout
-      DEFAULT_FONT_SIZE = 12
+      DEFAULT_FONT_SIZE = T.let(T.unsafe(nil), Numeric)
 
       sig { params(runs: T::Array[PDF::Reader::TextRun], mediabox: T.any(T::Array[Numeric], PDF::Reader::Rectangle)).void }
-      def initialize(runs, mediabox); end
+      def initialize(runs, mediabox)
+        @mediabox = T.let(T.unsafe(nil), PDF::Reader::Rectangle)
+        @runs = T.let(T.unsafe(nil), T::Array[PDF::Reader::TextRun])
+        @mean_font_size = T.let(T.unsafe(nil), Numeric)
+        @median_glyph_width = T.let(T.unsafe(nil), Numeric)
+        @x_offset = T.let(T.unsafe(nil), Numeric)
+        @y_offset = T.let(T.unsafe(nil), Numeric)
+        @row_count = T.let(T.unsafe(nil), T.nilable(Integer))
+        @col_count = T.let(T.unsafe(nil), T.nilable(Integer))
+        @row_multiplier = T.let(T.unsafe(nil), T.nilable(Numeric))
+        @col_multiplier = T.let(T.unsafe(nil), T.nilable(Numeric))
+      end
 
       sig { returns(String) }
       def to_s; end
@@ -926,6 +1005,12 @@ module PDF
 
       sig { params(mediabox: T.untyped).returns(T.untyped) }
       def process_mediabox(mediabox); end
+
+      sig { returns(Numeric) }
+      def page_width; end
+
+      sig { returns(Numeric) }
+      def page_height; end
     end
 
     class PageState
@@ -1110,81 +1195,7 @@ module PDF
     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,
-    }
+      OPERATORS = T.let(T.unsafe(nil), T::Hash[String, Symbol])
     end
 
     class Parser
@@ -1332,25 +1343,28 @@ module PDF
     end
 
     class Reference
-      sig { returns(T.untyped) }
+      sig { returns(Integer) }
       attr_reader :id
 
-      sig { returns(T.untyped) }
+      sig { returns(Integer) }
       attr_reader :gen
 
-      sig { params(id: T.untyped, gen: T.untyped).void }
-      def initialize(id, gen); end
+      sig { params(id: Integer, gen: Integer).void }
+      def initialize(id, gen)
+        @id = T.let(T.unsafe(nil), Integer)
+        @gen = T.let(T.unsafe(nil), Integer)
+      end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[PDF::Reader::Reference]) }
       def to_a; end
 
-      sig { returns(T.untyped) }
+      sig { returns(Integer) }
       def to_i; end
 
-      sig { params(obj: T.untyped).returns(T.untyped) }
+      sig { params(obj: Object).returns(T::Boolean) }
       def ==(obj); end
 
-      sig { returns(T.untyped) }
+      sig { returns(Integer) }
       def hash; end
     end
 
@@ -1386,31 +1400,36 @@ module PDF
       def series(*methods); end
     end
 
-    module ResourceMethods
-      extend T::Helpers
+    class Resources
 
-      sig { returns(T.untyped) }
+      sig { params(objects: PDF::Reader::ObjectHash, resources: T::Hash[T.untyped, T.untyped]).void }
+      def initialize(objects, resources)
+        @objects = T.let(T.unsafe(nil), PDF::Reader::ObjectHash)
+        @resources = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped])
+      end
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       def color_spaces; end
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       def fonts; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       def graphic_states; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       def patterns; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[Symbol]) }
       def procedure_sets; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       def properties; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       def shadings; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, PDF::Reader::Stream]) }
       def xobjects; end
     end
 
@@ -1479,54 +1498,68 @@ module PDF
 
     class SynchronizedCache
       sig { void }
-      def initialize; end
+      def initialize
+        @cache = T.let(T.unsafe(nil), T::Hash[Object, T.untyped])
+        @mutex = T.let(T.unsafe(nil), Mutex)
+      end
 
-      sig { params(key: T.untyped).returns(T.untyped) }
+      sig { params(key: Object).returns(T.untyped) }
       def [](key); end
 
-      sig { params(key: T.untyped, value: T.untyped).returns(T.untyped) }
+      sig { params(key: Object, value: T.nilable(Object)).returns(T.untyped) }
       def []=(key, value); end
     end
 
     class TextRun
       include Comparable
 
-      sig { returns(T.untyped) }
-      attr_reader :x
-
-      sig { returns(T.untyped) }
-      attr_reader :y
-
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :width
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :font_size
 
-      sig { returns(T.untyped) }
+      sig { returns(String) }
       attr_reader :text
 
+      sig { returns(PDF::Reader::Point) }
+      attr_reader :origin
+
       sig do
         params(
-          x: T.untyped,
-          y: T.untyped,
-          width: T.untyped,
-          font_size: T.untyped,
-          text: T.untyped
+          x: Numeric,
+          y: Numeric,
+          width: Numeric,
+          font_size: Numeric,
+          text: String
         ).void
       end
-      def initialize(x, y, width, font_size, text); end
+      def initialize(x, y, width, font_size, text)
+        @origin = T.let(T.unsafe(nil), PDF::Reader::Point)
+        @width = T.let(T.unsafe(nil), Numeric)
+        @font_size = T.let(T.unsafe(nil), Numeric)
+        @text = T.let(T.unsafe(nil), String)
+        @endx = T.let(T.unsafe(nil), T.nilable(Numeric))
+        @endy = T.let(T.unsafe(nil), T.nilable(Numeric))
+        @mergable_range = T.let(T.unsafe(nil), T.nilable(T::Range[Numeric]))
+      end
 
       sig { params(other: T.untyped).returns(T.untyped) }
       def <=>(other); end
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       def endx; end
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       def endy; end
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
+      def x; end
+
+      sig { returns(Numeric) }
+      def y; end
+
+      sig { returns(Numeric) }
       def mean_character_width; end
 
       sig { params(other: PDF::Reader::TextRun).returns(T::Boolean) }
@@ -1535,22 +1568,22 @@ module PDF
       sig { params(other: PDF::Reader::TextRun).returns(PDF::Reader::TextRun) }
       def +(other); end
 
-      sig { returns(T.untyped) }
+      sig { returns(String) }
       def inspect; end
 
-      sig { params(other_run: T.untyped).returns(T.untyped) }
+      sig { params(other_run: T.untyped).returns(T::Boolean) }
       def intersect?(other_run); end
 
-      sig { params(other_run: T.untyped).returns(T.untyped) }
+      sig { params(other_run: T.untyped).returns(Numeric) }
       def intersection_area_percent(other_run); end
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       def area; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Range[Numeric]) }
       def mergable_range; end
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       def character_count; end
     end
 
@@ -1560,120 +1593,130 @@ module PDF
     end
 
     class TransformationMatrix
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :a
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :b
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :c
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :d
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :e
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :f
 
       sig do
         params(
-          a: T.untyped,
-          b: T.untyped,
-          c: T.untyped,
-          d: T.untyped,
-          e: T.untyped,
-          f: T.untyped
+          a: Numeric,
+          b: Numeric,
+          c: Numeric,
+          d: Numeric,
+          e: Numeric,
+          f: Numeric
         ).void
       end
-      def initialize(a, b, c, d, e, f); end
+      def initialize(a, b, c, d, e, f)
+        @a = T.let(T.unsafe(nil), Numeric)
+        @b = T.let(T.unsafe(nil), Numeric)
+        @c = T.let(T.unsafe(nil), Numeric)
+        @d = T.let(T.unsafe(nil), Numeric)
+        @e = T.let(T.unsafe(nil), Numeric)
+        @f = T.let(T.unsafe(nil), Numeric)
+      end
 
-      sig { returns(T.untyped) }
+      sig { returns(String) }
       def inspect; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[Numeric]) }
       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)
+          a: Numeric,
+          b: Numeric,
+          c: Numeric,
+          d: Numeric,
+          e: Numeric,
+          f: Numeric
+        ).returns(PDF::Reader::TransformationMatrix)
       end
-      def multiply!(a, b = nil, c = nil, d = nil, e = nil, f = nil); end
+      def multiply!(a, b, c, d, e, f); end
 
-      sig { params(e2: T.untyped).returns(T.untyped) }
+      sig { params(e2: Numeric).void }
       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)
+          a2: Numeric,
+          b2: Numeric,
+          c2: Numeric,
+          d2: Numeric,
+          e2: Numeric,
+          f2: Numeric
+        ).void
       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)
+          a2: Numeric,
+          b2: Numeric,
+          c2: Numeric,
+          d2: Numeric,
+          e2: Numeric,
+          f2: Numeric
+        ).void
       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)
+          a2: Numeric,
+          b2: Numeric,
+          c2: Numeric,
+          d2: Numeric,
+          e2: Numeric,
+          f2: Numeric
+        ).void
       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)
+          a2: Numeric,
+          b2: Numeric,
+          c2: Numeric,
+          d2: Numeric,
+          e2: Numeric,
+          f2: Numeric
+        ).void
       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)
+          a2: Numeric,
+          b2: Numeric,
+          c2: Numeric,
+          d2: Numeric,
+          e2: Numeric,
+          f2: Numeric
+        ).void
       end
       def faster_multiply!(a2, b2, c2, d2, e2, f2); end
     end
 
     class TypeCheck
 
+      sig { params(obj: T.untyped).returns(Integer) }
+      def self.cast_to_int!(obj); end
+
       sig { params(obj: T.untyped).returns(Numeric) }
       def self.cast_to_numeric!(obj); end
 
@@ -1682,6 +1725,15 @@ module PDF
 
       sig { params(obj: T.untyped).returns(T.nilable(Symbol)) }
       def self.cast_to_symbol(obj); end
+
+      sig { params(obj: T.untyped).returns(Symbol) }
+      def self.cast_to_symbol!(obj); end
+
+      sig { params(obj: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+      def self.cast_to_pdf_dict!(obj); end
+
+      sig { params(obj: T.untyped).returns(T::Hash[Symbol, PDF::Reader::Stream]) }
+      def self.cast_to_pdf_dict_with_stream_values!(obj); end
     end
 
     class ValidatingReceiver
@@ -1785,12 +1837,18 @@ module PDF
 
     class XRef
       include Enumerable
+      extend T::Generic # Provides `type_member` helper
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       attr_reader :trailer
 
-      sig { params(io: T.untyped).void }
-      def initialize(io); end
+      sig { params(io: T.any(IO, Tempfile, StringIO)).void }
+      def initialize(io)
+        @io = T.let(T.unsafe(nil), T.any(IO, Tempfile, StringIO))
+        @junk_offset = T.let(T.unsafe(nil), Integer)
+        @xref = T.let(T.unsafe(nil), T::Hash[Integer, T::Hash[Integer, Integer]])
+        @trailer = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped])
+      end
 
       sig { returns(T.untyped) }
       def size; end
@@ -1854,7 +1912,9 @@ module PDF
 
       class Depredict
         sig { params(options: T::Hash[T.untyped, T.untyped]).void }
-        def initialize(options = {}); end
+        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
@@ -1915,62 +1975,72 @@ module PDF
 
     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(font: T.untyped).void }
-        def initialize(font); end
-
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        BUILTINS = T.let(T.unsafe(nil), T::Array[Symbol])
+
+        @@all_metrics = T.let(T.unsafe(nil), T.nilable(PDF::Reader::SynchronizedCache))
+
+        sig { params(font: PDF::Reader::Font).void }
+        def initialize(font)
+          @font = T.let(T.unsafe(nil), PDF::Reader::Font)
+          @metrics = T.let(T.unsafe(nil), AFM::Font)
+        end
+
+        sig { params(code_point: T.nilable(Integer)).returns(Numeric) }
         def glyph_width(code_point); end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: Integer).returns(T::Boolean) }
         def control_character?(code_point); end
 
-        sig { params(font_name: T.untyped).returns(T.untyped) }
+        sig { params(font_name: T.nilable(Symbol)).returns(String) }
         def extract_basefont(font_name); end
       end
 
       class Composite
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+        sig { params(font: PDF::Reader::Font).void }
+        def initialize(font)
+          @font = T.let(T.unsafe(nil), PDF::Reader::Font)
+          @widths = T.let(T.unsafe(nil), PDF::Reader::CidWidths)
+        end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: T.nilable(Integer)).returns(Numeric) }
         def glyph_width(code_point); end
       end
 
       class TrueType
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+        sig { params(font: PDF::Reader::Font).void }
+        def initialize(font)
+          @font = T.let(T.unsafe(nil), PDF::Reader::Font)
+          @missing_width = T.let(T.unsafe(nil), Numeric)
+        end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: T.nilable(Integer)).returns(Numeric) }
         def glyph_width(code_point); end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: Integer).returns(T.nilable(Numeric)) }
         def glyph_width_from_font(code_point); end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: Integer).returns(T.nilable(Numeric)) }
         def glyph_width_from_descriptor(code_point); end
       end
 
       class TypeOneOrThree
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+        sig { params(font: PDF::Reader::Font).void }
+        def initialize(font)
+          @font = T.let(T.unsafe(nil), PDF::Reader::Font)
+          @missing_width = T.let(T.unsafe(nil), Numeric)
+        end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: T.nilable(Integer)).returns(Numeric) }
         def glyph_width(code_point); end
       end
 
       class TypeZero
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+        sig { params(font: PDF::Reader::Font).void }
+        def initialize(font)
+          @font = T.let(T.unsafe(nil), PDF::Reader::Font)
+        end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: T.nilable(Integer)).returns(Numeric) }
         def glyph_width(code_point); end
       end
     end