pdf-reader 2.7.0 → 2.9.2

data/rbi/pdf-reader.rbi

@@ -43,6 +43,32 @@ module PDF
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def root; end
 
+    class AesV2SecurityHandler
+      sig { params(key: String).void }
+      def initialize(key)
+        @encrypt_key = T.let(T.unsafe(nil), String)
+      end
+
+      sig { params(buf: String, ref: PDF::Reader::Reference).returns(String) }
+      def decrypt(buf, ref); end
+    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 { params(buf: String, ref: PDF::Reader::Reference).returns(String) }
+      def decrypt(buf, ref); end
+    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
+    end
+
     class Buffer
       TOKEN_WHITESPACE = [0x00, 0x09, 0x0A, 0x0C, 0x0D, 0x20]
       TOKEN_DELIMITER = [0x25, 0x3C, 0x3E, 0x28, 0x5B, 0x7B, 0x29, 0x5D, 0x7D, 0x2F]
@@ -58,67 +84,67 @@ module PDF
       WHITE_SPACE = [LF, CR, ' ']
       TRAILING_BYTECOUNT = 5000
 
-      sig { returns(T.untyped) }
+      sig { returns(Integer) }
       attr_reader :pos
 
-      sig { params(io: T.untyped, opts: T.untyped).void }
-      def initialize(io, opts = {}); 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 { returns(T.untyped) }
+      sig { returns(T::Boolean) }
       def empty?; end
 
-      sig { params(bytes: T.untyped, opts: T.untyped).returns(T.untyped) }
+      sig { params(bytes: Integer, opts: T::Hash[Symbol, T.untyped]).returns(T.nilable(String)) }
       def read(bytes, opts = {}); end
 
-      sig { returns(T.untyped) }
+      sig { returns(T.any(NilClass, String, PDF::Reader::Reference)) }
       def token; end
 
-      sig { returns(T.untyped) }
+      sig { returns(Integer) }
       def find_first_xref_offset; end
 
-      sig { returns(T.untyped) }
+      sig { void }
       def check_size_is_non_zero; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Boolean) }
       def in_content_stream?; end
 
-      sig { returns(T.untyped) }
+      sig { void }
       def reset_pos; end
 
-      sig { returns(T.untyped) }
+      sig { void }
       def save_pos; end
 
-      sig { returns(T.untyped) }
+      sig { void }
       def prepare_tokens; end
 
-      sig { returns(T.untyped) }
+      sig { returns(Symbol) }
       def state; end
 
-      sig { returns(T.untyped) }
+      sig { void }
       def merge_indirect_reference; end
 
-      sig { returns(T.untyped) }
+      sig { void }
       def prepare_inline_token; end
 
-      sig { returns(T.untyped) }
+      sig { void }
       def prepare_hex_token; end
 
-      sig { returns(T.untyped) }
+      sig { void }
       def prepare_literal_token; end
 
-      sig { returns(T.untyped) }
+      sig { void }
       def prepare_regular_token; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Integer)) }
       def peek_byte; end
-
-      sig { params(token: T.untyped).returns(T.untyped) }
-      def string_token(token); end
     end
 
     class CidWidths
-      extend Forwardable
-
       sig { params(default: T.untyped, array: T.untyped).void }
       def initialize(default, array); end
 
@@ -133,7 +159,6 @@ module PDF
     end
 
     class CMap
-      extend T::Sig
       CMAP_KEYWORDS = {
       "begincodespacerange" => 1,
       "endcodespacerange" => 1,
@@ -150,33 +175,35 @@ module PDF
       attr_reader :map
 
       sig { params(data: String).void }
-      def initialize(data); end
+      def initialize(data)
+        @map = T.let(T.unsafe(nil), T::Hash[Integer, T::Array[Integer]])
+      end
 
-      sig { params(data: String).void }
-      def process_data(data); end
+      sig { params(data: String, initial_mode: Symbol).void }
+      def process_data(data, initial_mode = :none); end
 
       sig { returns(Integer) }
       def size; end
 
-      sig { params(c: T.untyped).returns(T.untyped) }
+      sig { params(c: Integer).returns(T::Array[Integer]) }
       def decode(c); end
 
-      sig { params(instructions: T.untyped).returns(T.untyped) }
+      sig { params(instructions: String).returns(PDF::Reader::Parser) }
       def build_parser(instructions); end
 
-      sig { params(str: T.untyped).returns(T.untyped) }
+      sig { params(str: String).returns(T::Array[Integer]) }
       def str_to_int(str); end
 
-      sig { params(instructions: T.untyped).returns(T.untyped) }
+      sig { params(instructions: T::Array[String]).void }
       def process_bfchar_instructions(instructions); end
 
-      sig { params(instructions: T.untyped).returns(T.untyped) }
+      sig { params(instructions: T::Array[T.any(T::Array[String], String)]).void }
       def process_bfrange_instructions(instructions); end
 
-      sig { params(start_code: T.untyped, end_code: T.untyped, dst: T.untyped).returns(T.untyped) }
+      sig { params(start_code: String, end_code: String, dst: String).void }
       def bfrange_type_one(start_code, end_code, dst); end
 
-      sig { params(start_code: T.untyped, end_code: T.untyped, dst: T.untyped).returns(T.untyped) }
+      sig { params(start_code: String, end_code: String, dst: T::Array[String]).void }
       def bfrange_type_two(start_code, end_code, dst); end
     end
 
@@ -197,13 +224,13 @@ module PDF
       sig { returns(T.untyped) }
       def differences; end
 
-      sig { params(str: T.untyped).returns(T.untyped) }
+      sig { params(str: String).returns(String) }
       def to_utf8(str); end
 
-      sig { params(glyph_code: T.untyped).returns(T.untyped) }
+      sig { params(glyph_code: Integer).returns(String) }
       def int_to_utf8_string(glyph_code); end
 
-      sig { params(glyph_code: T.untyped).returns(T.untyped) }
+      sig { params(glyph_code: Integer).returns(T::Array[Symbol]) }
       def int_to_name(glyph_code); end
 
       sig { returns(T.untyped) }
@@ -247,8 +274,14 @@ module PDF
       sig { params(object: Object, name: String, klass: Module).void }
       def self.validate_type(object, name, klass); end
 
+      sig { params(object: Object, name: String, klass: Module).void }
+      def self.validate_type_as_malformed(object, name, klass); end
+
       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
@@ -383,7 +416,7 @@ module PDF
       sig { returns(T.untyped) }
       attr_reader :font_flags
 
-      sig { params(ohash: T.untyped, fd_hash: T.untyped).void }
+      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) }
@@ -447,6 +480,38 @@ module PDF
       def load_adobe_glyph_mapping; end
     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(pass: String).returns(String) }
+      def key(pass); end
+
+      sig { params(password: T.untyped).returns(T.untyped) }
+      def auth_owner_pass(password); end
+
+      sig { params(password: T.untyped).returns(T.untyped) }
+      def auth_user_pass(password); end
+
+      sig { params(password: String).returns(T.nilable(String)) }
+      def auth_owner_pass_r6(password); end
+
+      sig { params(password: String).returns(T.nilable(String)) }
+      def auth_user_pass_r6(password); end
+
+      sig { params(password: String, salt: String, user_key: String).returns(String)}
+      def r6_digest(password, salt, user_key = ''); end
+
+      sig { params(str: String).returns(Integer)}
+      def unpack_128bit_bigendian_int(str); end
+    end
+
     class LZW
       CODE_EOD = 257
       CODE_CLEAR_TABLE = 256
@@ -484,9 +549,6 @@ module PDF
     end
 
     class NullSecurityHandler
-      sig { params(encrypt: T.untyped).returns(T.untyped) }
-      def self.supports?(encrypt); end
-
       sig { params(buf: T.untyped, _ref: T.untyped).returns(T.untyped) }
       def decrypt(buf, _ref); end
     end
@@ -579,9 +641,45 @@ module PDF
       sig { params(key: T.untyped).returns(T.untyped) }
       def object(key); end
 
+      sig { params(key: T.untyped).returns(T.nilable(T::Array[T.untyped])) }
+      def deref_array(key); end
+
+      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])) }
+      def deref_hash(key); end
+
+      sig { params(key: T.untyped).returns(T.nilable(Symbol)) }
+      def deref_name(key); end
+
+      sig { params(key: T.untyped).returns(T.any(Symbol, T::Array[T.untyped], NilClass)) }
+      def deref_name_or_array(key); end
+
+      sig { params(key: T.untyped).returns(T.nilable(Integer)) }
+      def deref_integer(key); end
+
+      sig { params(key: T.untyped).returns(T.nilable(Numeric)) }
+      def deref_number(key); end
+
+      sig { params(key: T.untyped).returns(T.nilable(PDF::Reader::Stream)) }
+      def deref_stream(key); end
+
+      sig { params(key: T.untyped).returns(T.nilable(String)) }
+      def deref_string(key); 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(key: T.untyped).returns(T.untyped) }
       def deref!(key); end
 
+      sig { params(key: T.untyped).returns(T::Array[T.untyped]) }
+      def deref_array!(key); end
+
+      sig { params(key: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+      def deref_hash!(key); end
+
       sig { params(key: T.untyped, local_default: T.untyped).returns(T.untyped) }
       def fetch(key, local_default = nil); end
 
@@ -594,22 +692,22 @@ module PDF
       sig { params(block: T.untyped).returns(T.untyped) }
       def each_value(&block); end
 
-      sig { returns(T.untyped) }
+      sig { returns(Integer) }
       def size; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Boolean) }
       def empty?; end
 
-      sig { params(check_key: T.untyped).returns(T.untyped) }
+      sig { params(check_key: T.untyped).returns(T::Boolean) }
       def has_key?(check_key); end
 
-      sig { params(value: T.untyped).returns(T.untyped) }
+      sig { params(value: T.untyped).returns(T::Boolean) }
       def has_value?(value); end
 
-      sig { returns(T.untyped) }
+      sig { returns(String) }
       def to_s; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[PDF::Reader::Reference]) }
       def keys; end
 
       sig { returns(T.untyped) }
@@ -621,13 +719,13 @@ module PDF
       sig { returns(T.untyped) }
       def to_a; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[PDF::Reader::Reference]) }
       def page_references; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Boolean) }
       def encrypted?; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Boolean) }
       def sec_handler?; end
 
       sig { params(key: T.untyped).returns(T.untyped) }
@@ -639,13 +737,10 @@ module PDF
       sig { params(key: T.untyped, seen: T.untyped).returns(T.untyped) }
       def deref_internal!(key, seen); end
 
-      sig { params(opts: T.untyped).returns(T.untyped) }
-      def build_security_handler(opts = {}); end
-
       sig { params(ref: T.untyped, obj: T.untyped).returns(T.untyped) }
       def decrypt(ref, obj); end
 
-      sig { params(offset: T.untyped).returns(T.untyped) }
+      sig { params(offset: Integer).returns(PDF::Reader::Buffer) }
       def new_buffer(offset = 0); end
 
       sig { returns(T.untyped) }
@@ -654,13 +749,13 @@ module PDF
       sig { returns(T.untyped) }
       def object_streams; end
 
-      sig { params(ref: T.untyped).returns(T.untyped) }
-      def get_page_objects(ref); 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 { returns(T.untyped) }
+      sig { returns(Float) }
       def read_version; end
 
-      sig { params(input: T.untyped).returns(T.untyped) }
+      sig { params(input: T.untyped).returns(IO) }
       def extract_io_from(input); end
 
       sig { params(input: T.untyped).returns(T.untyped) }
@@ -688,7 +783,6 @@ module PDF
     end
 
     class OverlappingRunsFilter
-      extend T::Sig
       OVERLAPPING_THRESHOLD = 0.5
 
       sig { params(runs: T::Array[PDF::Reader::TextRun]).returns(T::Array[PDF::Reader::TextRun]) }
@@ -699,8 +793,6 @@ module PDF
     end
 
     class EventPoint
-      extend T::Sig
-
       sig { returns(Numeric) }
       attr_reader :x
 
@@ -750,8 +842,11 @@ module PDF
       sig { returns(T::Array[Numeric]) }
       def origin; end
 
-      sig { returns(String) }
-      def text; end
+      sig { params(opts: T::Hash[Symbol, T.untyped]).returns(T::Array[PDF::Reader::TextRun]) }
+      def runs(opts = {}); end
+
+      sig { params(opts: T::Hash[Symbol, T.untyped]).returns(String) }
+      def text(opts = {}); end
 
       sig { params(receivers: T.untyped).void }
       def walk(*receivers); end
@@ -771,7 +866,7 @@ module PDF
       sig { returns(T::Hash[Symbol, T.untyped]) }
       def root; end
 
-      sig { returns(T::Hash[Symbol, T.untyped]) }
+      sig { returns(PDF::Reader::Resources) }
       def resources; end
 
       sig { params(receivers: T.untyped, instructions: T.untyped).returns(T.untyped) }
@@ -786,15 +881,14 @@ module PDF
       sig { params(origin: T.untyped).returns(T.untyped) }
       def ancestors(origin = @page_object[:Parent]); end
 
-      sig { params(obj: T.untyped).returns(T.untyped) }
+      sig { params(obj: T::Hash[T.untyped, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
       def select_inheritable(obj); end
     end
 
     class PageLayout
-      extend T::Sig
       DEFAULT_FONT_SIZE = 12
 
-      sig { params(runs: T::Array[PDF::Reader::TextRun], mediabox: T::Array[Numeric]).void }
+      sig { params(runs: T::Array[PDF::Reader::TextRun], mediabox: T.any(T::Array[Numeric], PDF::Reader::Rectangle)).void }
       def initialize(runs, mediabox); end
 
       sig { returns(String) }
@@ -829,6 +923,9 @@ module PDF
 
       sig { params(haystack: T.untyped, needle: T.untyped, index: T.untyped).returns(T.untyped) }
       def local_string_insert(haystack, needle, index); end
+
+      sig { params(mediabox: T.untyped).returns(T.untyped) }
+      def process_mediabox(mediabox); end
     end
 
     class PageState
@@ -987,22 +1084,25 @@ module PDF
       sig { returns(T.untyped) }
       def content; end
 
-      sig { params(string: T.untyped).returns(T.untyped) }
+      sig { params(string: String).void }
       def show_text(string); end
 
-      sig { params(params: T.untyped).returns(T.untyped) }
+      sig { params(params: T::Array[T.untyped]).void }
       def show_text_with_positioning(params); end
 
-      sig { params(str: T.untyped).returns(T.untyped) }
+      sig { params(str: String).void }
       def move_to_next_line_and_show_text(str); end
 
-      sig { params(aw: T.untyped, ac: T.untyped, string: T.untyped).returns(T.untyped) }
+      sig { params(opts: T::Hash[Symbol, T.untyped]).returns(T::Array[PDF::Reader::TextRun]) }
+      def runs(opts = {}); end
+
+      sig { params(aw: Numeric, ac: Numeric, string: String).void }
       def set_spacing_next_line_show_text(aw, ac, string); end
 
       sig { params(label: T.untyped).returns(T.untyped) }
       def invoke_xobject(label); end
 
-      sig { params(string: T.untyped).returns(T.untyped) }
+      sig { params(string: String).void }
       def internal_show_text(string); end
 
       sig { params(x: T.untyped, y: T.untyped).returns(T.untyped) }
@@ -1087,6 +1187,48 @@ module PDF
     }
     end
 
+    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 Point
       sig do
         params(
@@ -1094,7 +1236,10 @@ module PDF
           y: Numeric,
         ).void
       end
-      def initialize(x, y); end
+      def initialize(x, y)
+        @x = T.let(T.unsafe(nil), Numeric)
+        @y = T.let(T.unsafe(nil), Numeric)
+      end
 
       sig { returns(Numeric) }
       def x; end
@@ -1121,7 +1266,21 @@ module PDF
       def method_missing(methodname, *args); end
     end
 
+    class Rc4SecurityHandler
+      sig { params(key: String).void }
+      def initialize(key)
+        @encrypt_key = T.let(T.unsafe(nil), String)
+      end
+
+      sig { params(buf: T.untyped, ref: T.untyped).returns(T.untyped) }
+      def decrypt(buf, ref); end
+    end
+
     class Rectangle
+
+      sig { params(arr: T::Array[Numeric]).returns(PDF::Reader::Rectangle) }
+      def self.from_array(arr); end
+
       sig do
         params(
           x1: Numeric,
@@ -1130,7 +1289,13 @@ module PDF
           y2: Numeric
         ).void
       end
-      def initialize(x1, y1, x2, y2); 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
 
       sig { returns(PDF::Reader::Point) }
       def bottom_left; end
@@ -1155,6 +1320,15 @@ module PDF
 
       sig { params(degrees: Integer).void }
       def apply_rotation(degrees); end
+
+      sig { params(point: PDF::Reader::Point).void }
+      def contains?(point); end
+
+      sig { params(other: PDF::Reader::Rectangle).void }
+      def ==(other); end
+
+      sig { params(x1: Numeric, y1: Numeric, x2: Numeric, y2: Numeric).void }
+      def set_corners(x1, y1, x2, y2); end
     end
 
     class Reference
@@ -1218,7 +1392,7 @@ module PDF
       sig { returns(T.untyped) }
       def color_spaces; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def fonts; end
 
       sig { returns(T.untyped) }
@@ -1240,50 +1414,34 @@ module PDF
       def xobjects; end
     end
 
-    class StandardSecurityHandler
-      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 { returns(T.untyped) }
-      attr_reader :key_length
-
-      sig { returns(T.untyped) }
-      attr_reader :revision
-
-      sig { returns(T.untyped) }
-      attr_reader :encrypt_key
-
-      sig { returns(T.untyped) }
-      attr_reader :owner_key
-
-      sig { returns(T.untyped) }
-      attr_reader :user_key
-
-      sig { returns(T.untyped) }
-      attr_reader :permissions
+    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.untyped) }
-      attr_reader :file_id
+      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.untyped) }
-      attr_reader :password
+      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 { params(opts: T.untyped).void }
-      def initialize(opts = {}); end
+      sig { params(encrypt: T.untyped).returns(T.untyped) }
+      def self.standard?(encrypt); end
 
       sig { params(encrypt: T.untyped).returns(T.untyped) }
-      def self.supports?(encrypt); end
+      def self.standard_v5?(encrypt); end
+    end
 
-      sig { params(buf: T.untyped, ref: T.untyped).returns(T.untyped) }
-      def decrypt(buf, ref); 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(buf: T.untyped, ref: T.untyped).returns(T.untyped) }
-      def decrypt_rc4(buf, ref); end
+      sig { params(opts: T::Hash[Symbol, T.untyped]).void }
+      def initialize(opts = {}); end
 
-      sig { params(buf: T.untyped, ref: T.untyped).returns(T.untyped) }
-      def decrypt_aes128(buf, ref); end
+      sig { params(pass: String).returns(String) }
+      def key(pass); end
 
       sig { params(p: T.untyped).returns(T.untyped) }
       def pad_pass(p = ""); end
@@ -1299,48 +1457,23 @@ module PDF
 
       sig { params(user_pass: T.untyped).returns(T.untyped) }
       def make_file_key(user_pass); end
-
-      sig { params(pass: T.untyped).returns(T.untyped) }
-      def build_standard_key(pass); end
-    end
-
-    class StandardSecurityHandlerV5
-      sig { returns(T.untyped) }
-      attr_reader :key_length
-
-      sig { returns(T.untyped) }
-      attr_reader :encrypt_key
-
-      sig { params(opts: T.untyped).void }
-      def initialize(opts = {}); end
-
-      sig { params(encrypt: T.untyped).returns(T.untyped) }
-      def self.supports?(encrypt); end
-
-      sig { params(buf: T.untyped, ref: T.untyped).returns(T.untyped) }
-      def decrypt(buf, ref); end
-
-      sig { params(password: T.untyped).returns(T.untyped) }
-      def auth_owner_pass(password); end
-
-      sig { params(password: T.untyped).returns(T.untyped) }
-      def auth_user_pass(password); end
-
-      sig { params(pass: T.untyped).returns(T.untyped) }
-      def build_standard_key(pass); end
     end
 
     class Stream
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       attr_accessor :hash
 
-      sig { returns(T.untyped) }
+      sig { returns(String) }
       attr_accessor :data
 
-      sig { params(hash: T.untyped, data: T.untyped).void }
-      def initialize(hash, data); 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
 
-      sig { returns(T.untyped) }
+      sig { returns(String) }
       def unfiltered_data; end
     end
 
@@ -1357,7 +1490,6 @@ module PDF
 
     class TextRun
       include Comparable
-      extend T::Sig
 
       sig { returns(T.untyped) }
       attr_reader :x
@@ -1540,6 +1672,109 @@ module PDF
       def faster_multiply!(a2, b2, c2, d2, e2, f2); end
     end
 
+    class TypeCheck
+
+      sig { params(obj: T.untyped).returns(Numeric) }
+      def self.cast_to_numeric!(obj); end
+
+      sig { params(string: T.untyped).returns(String) }
+      def self.cast_to_string!(string); end
+
+      sig { params(obj: T.untyped).returns(T.nilable(Symbol)) }
+      def self.cast_to_symbol(obj); end
+    end
+
+    class ValidatingReceiver
+      sig { params(wrapped: T.untyped).void }
+      def initialize(wrapped)
+        @wrapped = T.let(T.unsafe(nil), T.untyped)
+      end
+
+      sig { params(page: PDF::Reader::Page).void }
+      def page=(page); end
+
+      sig { params(args: T.untyped).void }
+      def save_graphics_state(*args); end
+
+      sig { params(args: T.untyped).void }
+      def restore_graphics_state(*args); end
+
+      sig { params(args: T.untyped).void }
+      def concatenate_matrix(*args); end
+
+      sig { params(args: T.untyped).void }
+      def begin_text_object(*args); end
+
+      sig { params(args: T.untyped).void }
+      def end_text_object(*args); end
+
+      sig { params(args: T.untyped).void }
+      def set_character_spacing(*args); end
+
+      sig { params(args: T.untyped).void }
+      def set_horizontal_text_scaling(*args); end
+
+      sig { params(args: T.untyped).void }
+      def set_text_font_and_size(*args); end
+
+      sig { params(args: T.untyped).void }
+      def set_text_leading(*args); end
+
+      sig { params(args: T.untyped).void }
+      def set_text_rendering_mode(*args); end
+
+      sig { params(args: T.untyped).void }
+      def set_text_rise(*args); end
+
+      sig { params(args: T.untyped).void }
+      def set_word_spacing(*args); end
+
+      sig { params(args: T.untyped).void }
+      def move_text_position(*args); end
+
+      sig { params(args: T.untyped).void }
+      def move_text_position_and_set_leading(*args); end
+
+      sig { params(args: T.untyped).void }
+      def set_text_matrix_and_text_line_matrix(*args); end
+
+      sig { params(args: T.untyped).void }
+      def move_to_start_of_next_line(*args); end
+
+      sig { params(args: T.untyped).void }
+      def show_text(*args); end
+
+      sig { params(args: T.untyped).void }
+      def show_text_with_positioning(*args); end
+
+      sig { params(args: T.untyped).void }
+      def move_to_next_line_and_show_text(*args); end
+
+      sig { params(args: T.untyped).void }
+      def set_spacing_next_line_show_text(*args); end
+
+      sig { params(args: T.untyped).void }
+      def invoke_xobject(*args); end
+
+      sig { params(args: T.untyped).void }
+      def begin_inline_image(*args); end
+
+      sig { params(args: T.untyped).void }
+      def begin_inline_image_data(*args); end
+
+      sig { params(args: T.untyped).void }
+      def end_inline_image(*args); end
+
+      sig { params(meth: T.untyped).returns(T::Boolean) }
+      def respond_to?(meth); end
+
+      sig { params(methodname: Symbol, args: T.untyped).void }
+      def method_missing(methodname, *args); end
+
+      sig { params(methodname: T.untyped, args: T.untyped).void }
+      def call_wrapped(methodname, *args); end
+    end
+
     class UnimplementedSecurityHandler
       sig { params(encrypt: T.untyped).returns(T.untyped) }
       def self.supports?(encrypt); end
@@ -1589,40 +1824,36 @@ module PDF
     end
 
     class ZeroWidthRunsFilter
-      extend T::Sig
-
       sig { params(runs: T::Array[PDF::Reader::TextRun]).returns(T::Array[PDF::Reader::TextRun]) }
       def self.exclude_zero_width_runs(runs); end
     end
 
     module Filter
-      sig { params(name: T.untyped, options: T.untyped).returns(T.untyped) }
+      sig { params(name: Symbol, options: T::Hash[T.untyped, T.untyped]).returns(T.untyped) }
       def self.with(name, options = {}); end
 
       class Ascii85
-        extend T::Sig
-
-        sig { params(options: T.untyped).void }
-        def initialize(options = {}); end
+        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
-        extend T::Sig
-
-        sig { params(options: T.untyped).void }
-        def initialize(options = {}); end
+        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
-        extend T::Sig
-
-        sig { params(options: T.untyped).void }
+        sig { params(options: T::Hash[T.untyped, T.untyped]).void }
         def initialize(options = {}); end
 
         sig { params(data: String).returns(String) }
@@ -1636,12 +1867,13 @@ module PDF
       end
 
       class Flate
-        extend T::Sig
         ZLIB_AUTO_DETECT_ZLIB_OR_GZIP = 47
         ZLIB_RAW_DEFLATE = -15
 
-        sig { params(options: T.untyped).void }
-        def initialize(options = {}); end
+        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
@@ -1651,28 +1883,30 @@ module PDF
       end
 
       class Lzw
-        extend T::Sig
-
-        sig { params(options: T.untyped).void }
-        def initialize(options = {}); end
+        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.untyped).void }
-        def initialize(options = {}); end
+        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
-        extend T::Sig
-
-        sig { params(options: T.untyped).void }
-        def initialize(options = {}); end
+        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