bidi2pdf 0.1.13 → 0.1.15

data/sig/bidi2pdf/notifications/instrumenter.rbs

@@ -0,0 +1,21 @@
+module Bidi2pdf
+  # rubocop: disable Lint/RescueException, Lint/SuppressedException
+  module Notifications
+    class Instrumenter
+      @id: untyped
+
+      attr_reader id: untyped
+
+      def initialize: () -> void
+
+      def notify: (untyped name, untyped payload) { (?) -> untyped } -> untyped
+
+      private
+
+      def create_event: (untyped name, untyped payload) -> untyped
+
+      # rubocop:disable  Style/CaseEquality
+      def notify_subscribers: (untyped name, untyped event) -> untyped
+    end
+  end
+end

data/sig/bidi2pdf/notifications/logging_subscriber.rbs

@@ -0,0 +1,41 @@
+module Bidi2pdf
+  module Notifications
+    # for reuse within ActiveSupport::LogSubscriber
+    module LoggingSubscriberActions
+      def handle_response: (untyped event) -> untyped
+
+      def send_cmd: (untyped event) -> untyped
+
+      def send_cmd_and_wait: (untyped event) -> (nil | untyped)
+
+      def session_close: (untyped event) -> (nil | untyped)
+
+      # rubocop: disable Metrics/AbcSize
+      def network_event_received: (untyped event) -> (nil | untyped)
+
+      # rubocop:disable  Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def network_idle: (untyped event) -> (nil | untyped)
+
+      def page_loaded: (untyped event) -> untyped
+
+      def print: (untyped event) -> untyped
+
+      private
+
+      def redact_sensitive_fields: (untyped obj, ?::Array[untyped] sensitive_keys) -> untyped
+    end
+
+    class LoggingSubscriber
+      @logger: untyped
+
+      include LoggingSubscriberActions
+
+      attr_accessor logger: untyped
+
+      # rubocop: disable Metrics/AbcSize, Metrics/CyclomaticComplexity,  Metrics/PerceivedComplexity
+      def initialize: (?logger: untyped) -> void
+
+      def unsubscribe: () -> untyped
+    end
+  end
+end

data/sig/bidi2pdf/notifications.rbs

@@ -0,0 +1,24 @@
+module Bidi2pdf
+  module Notifications
+    self.@subscribers: untyped
+
+    attr_reader self.subscribers: untyped
+
+    def self.instrument: (untyped name, ?::Hash[untyped, untyped] payload) ?{ (untyped) -> untyped } -> untyped
+
+    def self.subscribe: (untyped event_pattern) { (?) -> untyped } -> untyped
+
+    def self.unsubscribe: (untyped event_pattern, ?untyped? block) -> untyped
+
+    # rubocop: disable Style/CaseEquality
+    def self.listening?: (untyped name) -> untyped
+
+    private
+
+    def self.bidi2pdf_notification_instrumenter: () -> untyped
+
+    def self.notify: (untyped name, untyped payload) { (?) -> untyped } -> untyped
+
+    def self.normalize_pattern: (untyped pat) -> untyped
+  end
+end

data/sig/bidi2pdf/process_tree.rbs

@@ -10,7 +10,7 @@ module Bidi2pdf
 
     def children: (untyped of_pid) -> (::Array[untyped] | untyped)
 
-    def traverse: () { () -> untyped } -> untyped
+    def traverse: () { (?) -> untyped } -> untyped
 
     private
 
@@ -22,6 +22,6 @@ module Bidi2pdf
 
     def root_pids: () -> (::Array[untyped] | untyped)
 
-    def traverse_branch: (untyped pid, ?::Integer level) { () -> untyped } -> (nil | untyped)
+    def traverse_branch: (untyped pid, ?::Integer level) { (?) -> untyped } -> (nil | untyped)
   end
 end

data/sig/bidi2pdf/session_runner.rbs

@@ -1,9 +1,43 @@
 module Bidi2pdf
+  # Represents a runner for managing browser sessions and executing tasks
+  # using the Bidi2pdf library. This class handles the setup, configuration,
+  # and execution of browser-related workflows, including navigation, cookie
+  # management, and printing.
+  #
+  # @example Running a session
+  #   session_runner = Bidi2pdf::SessionRunner.new(
+  #     session: session,
+  #     url: "http://example.com",
+  #     inputfile: "input.html",
+  #     output: "output.pdf",
+  #     cookies: { "key" => "value" },
+  #     headers: { "Authorization" => "Bearer token" },
+  #     auth: { username: "user", password: "pass" },
+  #     wait_window_loaded: true,
+  #     wait_network_idle: true,
+  #     print_options: { landscape: true },
+  #     network_log_format: :json
+  #   )
+  #   session_runner.run
+  #
+  # @param [Object] session The browser session object to use.
+  # @param [String, nil] url The URL to navigate to in the browser session.
+  # @param [String, nil] inputfile The path to the input file to be processed if no URL is provided.
+  # @param [String, nil] output The path to the output file to be generated.
+  # @param [Hash] cookies A hash of cookies to set in the browser session. Defaults to an empty hash.
+  # @param [Hash] headers A hash of HTTP headers to include in the browser session. Defaults to an empty hash.
+  # @param [Hash, nil] auth Authentication credentials (e.g., username and password). Defaults to an empty hash.
+  # @param [Boolean] wait_window_loaded Whether to wait for the window to fully load. Defaults to false.
+  # @param [Boolean] wait_network_idle Whether to wait for the network to become idle. Defaults to false.
+  # @param [Hash] print_options Options for printing the page. Defaults to an empty hash.
+  # @param [Symbol] network_log_format The format for network logs. Defaults to :console.
   class SessionRunner
     @session: untyped
 
     @url: untyped
 
+    @inputfile: untyped
+
     @output: untyped
 
     @cookies: untyped
@@ -18,13 +52,18 @@ module Bidi2pdf
 
     @print_options: untyped
 
+    @network_log_format: untyped
+
     @window: untyped
 
     @tab: untyped
 
+    @user_context: untyped
+
     @uri: untyped
 
-    def initialize: (session: untyped, url: untyped, output: untyped, ?cookies: ::Hash[untyped, untyped], ?headers: ::Hash[untyped, untyped], ?auth: ::Hash[untyped, untyped], ?wait_window_loaded: bool, ?wait_network_idle: bool, ?print_options: ::Hash[untyped, untyped]) -> void
+    # rubocop: disable Metrics/ParameterLists
+    def initialize: (session: untyped, url: untyped, inputfile: untyped, output: untyped, ?cookies: ::Hash[untyped, untyped], ?headers: ::Hash[untyped, untyped], ?auth: ::Hash[untyped, untyped], ?wait_window_loaded: bool, ?wait_network_idle: bool, ?print_options: ::Hash[untyped, untyped], ?network_log_format: ::Symbol) -> void
 
     def run: () -> untyped
 
@@ -38,6 +77,7 @@ module Bidi2pdf
 
     def add_basic_auth: () -> (nil | untyped)
 
+    # rubocop: disable Metrics/AbcSize
     def run_flow: () -> untyped
 
     def uri: () -> untyped

data/sig/bidi2pdf/session_warmer.rbs

@@ -0,0 +1,221 @@
+module Bidi2pdf
+  # Keeps a small number of Chrome sessions pre-warmed (chromedriver started, WebSocket connected,
+  # browser ready) so a render can skip that startup latency on the request path. Isolation matches
+  # today's one-Chrome-per-render model exactly: every checked-out slot is used for exactly one
+  # +with_tab+ block and then retired (never returned to the cache) - only a fresh replacement is
+  # warmed in its place, off the request path. Checkout never waits for a warm slot: one is used if
+  # it is ready, otherwise a slot is created synchronously on the spot, i.e. today's exact behavior
+  # for that one render - including its failure mode: if that cold start fails, the error propagates
+  # out of +with_tab+ exactly as it would without the warmer.
+  #
+  # @example Rails initializer
+  #   Bidi2pdf::SessionWarmer.configure do |c|
+  #     c.size = 2
+  #     c.headless = true
+  #   end
+  #
+  # @example Per-request usage
+  #   Bidi2pdf::SessionWarmer.with_tab do |tab|
+  #     tab.navigate_to(url)
+  #     tab.print("invoice.pdf")
+  #   end
+  class SessionWarmer
+    self.@config: untyped
+
+    # Cleared first: if the constructor below raises, a stale, already-shut-down instance must
+    # not stay registered (it would keep serving cold slots but never warm again).
+    self.@instance: untyped
+
+    @config: untyped
+
+    @slot_factory: untyped
+
+    @mutex: untyped
+
+    @available: untyped
+
+    @replenish_threads: untyped
+
+    @warming: untyped
+
+    @shutdown: untyped
+
+    @reaper_wakeup: untyped
+
+    @reaper: untyped
+
+    # Configuration for the session warmer.
+    class Configuration
+      @size: untyped
+
+      @headless: untyped
+
+      @chrome_args: untyped
+
+      @remote_browser_url: untyped
+
+      @slot_factory: untyped
+
+      @max_idle_age: untyped
+
+      # @return [Integer] Number of Chrome slots to keep pre-warmed.
+      attr_accessor size: untyped
+
+      # @return [Boolean] Whether to run Chrome in headless mode.
+      attr_accessor headless: untyped
+
+      # @return [Array<String>] Chrome launch arguments.
+      attr_accessor chrome_args: untyped
+
+      # @return [String, nil] A remote chromedriver session URL (e.g. a `remote-chrome` sidecar). When
+      #   set, a slot connects directly to it instead of spawning a local ChromedriverManager -
+      #   mirrors Launcher#session's own local/remote branch.
+      attr_accessor remote_browser_url: untyped
+
+      # @return [#call, nil] Optional factory callable that returns a slot hash - injectable for tests.
+      #   A custom factory owns the cleanup of anything it half-built before raising: the warmer can
+      #   only retire a slot it was actually handed.
+      attr_accessor slot_factory: untyped
+
+      # @return [Numeric, nil] Seconds a warm slot may sit unused before it is retired and replaced.
+      #   A warm slot is an open, unauthenticated automation endpoint (chromedriver's port, Chrome's
+      #   debugging port) for as long as it idles, so that window is bounded by default. A slot older
+      #   than this is never handed out, and a background reaper recycles idle ones within roughly
+      #   1.25x this value even when no render ever comes. +nil+ disables the limit.
+      attr_accessor max_idle_age: untyped
+
+      DEFAULT_MAX_IDLE_AGE: 300
+
+      def initialize: () -> void
+
+      # @raise [ArgumentError] if a setting can't be honored - checked once, at construction.
+      def validate!: () -> untyped
+
+      private
+
+      def validate_size!: () -> (nil | untyped)
+
+      def validate_max_idle_age!: () -> (nil | untyped)
+    end
+
+    # Configures the warmer and eagerly (re)creates the singleton, warming config.size slots right
+    # here - at boot/configuration time, off the request path - instead of lazily on whichever
+    # request happens to trigger the first #with_tab (which would otherwise pay for every
+    # configured slot, serially, on that one unlucky request).
+    def self.configure: () ?{ (untyped) -> untyped } -> untyped
+
+    # Returns the warmer's configuration, initializing defaults if needed.
+    def self.config: () -> untyped
+
+    # Returns a callable that creates one real, fully-warmed Chrome slot from +config+. If building
+    # fails part-way (chromedriver up, but the session or its browser never came ready), whatever
+    # already exists is retired before the error propagates - no caller ever gets a reference to a
+    # half-built slot, so nobody else could clean it up.
+    def self.default_slot_factory: (untyped config) -> untyped
+
+    # Closes a slot's session and stops its chromedriver (nil for a remote slot, or for a part that
+    # was never created). Each step is independent: a failure in one is logged, never raised, and
+    # never skips the other.
+    def self.retire_slot: (session: untyped, manager: untyped) -> untyped
+
+    def self.safe_close: (untyped label) { () -> untyped } -> untyped
+
+    # Returns the shared singleton warmer instance, creating it (and pre-warming it) on first call.
+    def self.instance: () -> untyped
+
+    # Checks out a slot, yields a fresh tab for one render, then retires the slot.
+    def self.with_tab: () { (?) -> untyped } -> untyped
+
+    # Retires every currently-warm spare and resets the singleton.
+    def self.shutdown: () -> untyped
+
+    private
+
+    # Records each part in +parts+ the moment it exists, so #default_slot_factory's rescue can
+    # retire exactly what was created so far. Mirrors Launcher#session's local/remote branch.
+    def self.build_slot: (untyped config, untyped parts) -> { session: untyped, browser: untyped, manager: untyped }
+
+    def self.connect_remote: (untyped config, untyped parts) -> untyped
+
+    def self.start_local: (untyped config, untyped parts) -> untyped
+
+    public
+
+    def initialize: (untyped config, ?slot_factory: untyped?) -> void
+
+    # Checks out a slot, creates an isolated UserContext/Window/Tab for one render, yields the tab,
+    # then unconditionally closes those resources and retires the underlying slot.
+    def with_tab: () { (untyped) -> untyped } -> untyped
+
+    # Retires every currently-warm spare and waits for any in-flight background replenishment to
+    # finish (each of those, seeing @shutdown, retires its own result instead of stashing it - see
+    # #stash_or_retire). A subsequent #with_tab still works - it just falls back to a synchronous
+    # slot, since checkout never depends on a warm one being there.
+    def shutdown: () -> untyped
+
+    private
+
+    # Fail-fast on purpose (a Chrome that can't start at boot should be loud), but not leaky: if slot
+    # N fails, no instance is returned to own slots 1..N-1, so they are retired here first.
+    def prewarm: () -> untyped
+
+    def create_slot: () -> untyped
+
+    # Session#started? is just an internal flag set once at startup - it never flips back if Chrome,
+    # ChromeDriver, or the WebSocket dies externally while a slot sits idle in the cache. The
+    # client's own #open? is kept live by the reader thread noticing a real socket error, so
+    # checking it too catches that case - cheap (no network round trip), though still a heuristic,
+    # not a full liveness guarantee (a stuck-but-not-yet-disconnected socket still reads healthy).
+    def healthy?: (untyped slot) -> untyped
+
+    def now: () -> untyped
+
+    # Marks the moment a slot entered the cache - idle age counts from here, not from when its
+    # Chrome started, since it is the unattended waiting that max_idle_age bounds.
+    def stamp: (untyped slot) -> untyped
+
+    def expired?: (untyped slot) -> untyped
+
+    # Checkout alone can't bound idle time: with no traffic nothing would ever look at a spare. This
+    # thread does, four times per max_idle_age, so an unused slot is recycled within ~1.25x of it.
+    # Thread::Queue#pop(timeout:) doubles as an interruptible sleep - #shutdown pushes :stop.
+    def reap_loop: () -> untyped
+
+    def recycle_expired: () -> untyped
+
+    # A warm hit takes the spare and triggers a background replacement; a miss (empty cache, or a
+    # spare that died while idle) falls straight through to a synchronous slot - it never waits, so
+    # an under-provisioned warmer is never worse than not having one. A cold start that fails raises,
+    # as it would without the warmer.
+    #
+    # Oldest spare first (shift, not pop), so no slot lingers at the bottom of the cache while newer
+    # ones are used; and one past max_idle_age is never handed out, even if the reaper hasn't got to
+    # it yet - it is retired like a dead spare and this render cold-starts instead.
+    def checkout: () -> untyped
+
+    def cold_checkout: (untyped dead_slot) -> untyped
+
+    # Tops the cache up towards config.size, counting warmers already in flight. Deficit-based on
+    # purpose, not "replace what this checkout popped": that rule could never recover from a single
+    # failed warm (nothing stashed -> every later checkout a miss -> never replenished again), while
+    # replenishing unconditionally let @available grow without bound under a burst of misses.
+    # available + warming never exceeds config.size, and a failed warm frees its reservation, so the
+    # next checkout simply tries again.
+    #
+    # Threads are created and registered inside the same critical section, so #shutdown's snapshot
+    # can't miss one that has started but isn't listed yet (#warm_one needs this mutex to finish,
+    # so it just waits for it).
+    def replenish_async: () -> untyped
+
+    def warm_one: () -> untyped
+
+    # A replacement warmed after #shutdown has nothing to stash into - retire it immediately rather
+    # than leaking a live Chrome process that nothing will ever check out. Either way this warmer's
+    # reservation is released here, in the same critical section as the stash.
+    def stash_or_retire: (untyped slot) -> untyped
+
+    def retire: (untyped slot) -> untyped
+
+    def safe_close: (untyped label) { (?) -> untyped } -> untyped
+  end
+end

data/sig/bidi2pdf/test_helpers/configuration.rbs

@@ -0,0 +1,51 @@
+module Bidi2pdf
+  module TestHelpers
+    self.@configuration: untyped
+
+    class Configuration
+      @spec_dir: untyped
+
+      @docker_dir: untyped
+
+      @fixture_dir: untyped
+
+      @tmp_dir: untyped
+
+      @prefix: untyped
+
+      # @!attribute [rw] spec_dir
+      #   @return [Pathname] the directory where specs are located
+      attr_accessor spec_dir: untyped
+
+      # @!attribute [rw] tmp_dir
+      #   @return [String] the directory for temporary files
+      attr_accessor tmp_dir: untyped
+
+      # @!attribute [rw] prefix
+      #   @return [String] the prefix for temporary files
+      attr_accessor prefix: untyped
+
+      # @!attribute [rw] docker_dir
+      #  @return [String] the directory for Docker files
+      attr_accessor docker_dir: untyped
+
+      # @!attribute [rw] fixture_dir
+      # @return [String] the directory for fixture files
+      attr_accessor fixture_dir: untyped
+
+      def initialize: () -> void
+    end
+
+    # Retrieves the current configuration object for TestHelpers.
+    # @return [Configuration] the configuration object
+    def self.configuration: () -> untyped
+
+    # Sets the configuration object for TestHelpers.
+    # @param [Configuration] config the configuration object to set
+    attr_writer self.configuration: untyped
+
+    # Allows configuration of TestHelpers by yielding the configuration object.
+    # @yieldparam [Configuration] configuration the configuration object to modify
+    def self.configure: () { (untyped) -> untyped } -> untyped
+  end
+end

data/sig/bidi2pdf/test_helpers/images/extractor.rbs

@@ -0,0 +1,43 @@
+module Bidi2pdf
+  module TestHelpers
+    module Images
+      class Extractor
+        @pages: untyped
+
+        @logger: untyped
+
+        @extracted_images: untyped
+
+        include PDFReaderUtils
+
+        include TIFFHelper
+
+        attr_reader pages: untyped
+
+        attr_reader logger: untyped
+
+        def initialize: (untyped pdf_data, ?logger: untyped) -> void
+
+        def all_images: () -> untyped
+
+        def image_on_page: (untyped page_number, untyped image_number) -> (nil | untyped)
+
+        def images_on_page: (untyped page_number) -> untyped
+
+        private
+
+        def extracted_images: () -> untyped
+
+        def extract_images: (untyped page) -> (nil | untyped)
+
+        def process_image_stream: (untyped stream) -> (nil | untyped)
+
+        def extract_raw_image_data: (untyped stream, untyped filter) -> untyped
+
+        def handle_compressed_image: (untyped stream) -> untyped
+
+        def create_vips_image: (untyped raw, untyped filter) -> untyped
+      end
+    end
+  end
+end

data/sig/bidi2pdf/test_helpers/images/image_similarity_checker.rbs

@@ -0,0 +1,35 @@
+module Bidi2pdf
+  module TestHelpers
+    module Images
+      class ImageSimilarityChecker
+        @expected_image: untyped
+
+        @image_to_check: untyped
+
+        @expected_fingerprint: untyped
+
+        @actual_fingerprint: untyped
+
+        @distance: untyped
+
+        def initialize: (untyped expected_image, untyped image_to_check) -> void
+
+        def similar?: (?tolerance: ::Integer) -> untyped
+
+        def very_similar?: () -> untyped
+
+        def slightly_similar?: () -> untyped
+
+        def different?: () -> untyped
+
+        def expected_fingerprint: () -> untyped
+
+        def actual_fingerprint: () -> untyped
+
+        def distance: () -> untyped
+
+        def fingerprint: (untyped image) -> untyped
+      end
+    end
+  end
+end

data/sig/bidi2pdf/test_helpers/images/tiff_helper.rbs

@@ -0,0 +1,70 @@
+module Bidi2pdf
+  module TestHelpers
+    module Images
+      # rubocop: disable  Metrics/ModuleLength, Metrics/AbcSize
+      module TIFFHelper
+        # TIFF Tag IDs
+        IMAGE_WIDTH: 256
+
+        IMAGE_LENGTH: 257
+
+        BITS_PER_SAMPLE: 258
+
+        COMPRESSION: 259
+
+        PHOTOMETRIC_INTERPRETATION: 262
+
+        STRIP_OFFSETS: 273
+
+        SAMPLES_PER_PIXEL: 277
+
+        ROWS_PER_STRIP: 278
+
+        STRIP_BYTE_COUNTS: 279
+
+        PLANAR_CONFIGURATION: 284
+
+        INK_SET: 332
+
+        # TIFF Data Types
+        TYPE_SHORT: 3
+
+        TYPE_LONG: 4
+
+        # TIFF Compression Types
+        COMPRESSION_NONE: 1
+
+        COMPRESSION_CCITT_G3: 3
+
+        COMPRESSION_CCITT_G4: 4
+
+        # TIFF Photometric Interpretations
+        PHOTO_WHITE_IS_ZERO: 0
+
+        PHOTO_BLACK_IS_ZERO: 1
+
+        PHOTO_RGB: 2
+
+        PHOTO_SEPARATION: 5
+
+        # Planar Configuration
+        PLANAR_CHUNKY: 1
+
+        def tiff_header: (untyped hash, untyped data) -> untyped
+
+        # See:
+        #    * https://gist.github.com/gstorer/f6a9f1dfe41e8e64dcf58d07afa9ab2a
+        #    * https://github.com/yob/pdf-reader/blob/main/examples/extract_images.rb
+        def pack_tiff: (untyped entries) -> untyped
+
+        def tiff_header_for_gray: (untyped hash, untyped data) -> untyped
+
+        def tiff_header_for_ccitt: (untyped hash, untyped data) -> untyped
+
+        def tiff_header_for_cmyk: (untyped hash, untyped data) -> untyped
+
+        def tiff_header_for_rgb: (untyped hash, untyped data) -> untyped
+      end
+    end
+  end
+end

data/sig/bidi2pdf/test_helpers/pdf_file_helper.rbs

@@ -0,0 +1,23 @@
+module Bidi2pdf
+  module TestHelpers
+    # This module provides helper methods for handling PDF files in tests.
+    # It includes methods for debugging, storing, and managing PDF files.
+    module PdfFileHelper
+      def reporter: () -> untyped
+
+      # Executes a block with the given PDF data and handles debugging in case of test failures.
+      # If an expectation fails, the PDF data is saved to a file for debugging purposes.
+      # @param [String] pdf_data the PDF data to debug
+      # @yield [String] yields the PDF data to the given block
+      # @raise [RSpec::Expectations::ExpectationNotMetError] re-raises the exception after saving the PDF
+      def with_pdf_debug: (untyped pdf_data) { (untyped) -> untyped } -> untyped
+
+      # Stores the given PDF data to a file with a specified filename prefix.
+      # The file is saved in a temporary directory.
+      # @param [String] pdf_data the PDF data to store
+      # @param [String] filename_prefix the prefix for the generated filename (default: "test")
+      # @return [String] the full path to the saved PDF file
+      def store_pdf_file: (untyped pdf_data, ?::String filename_prefix) -> untyped
+    end
+  end
+end

data/sig/bidi2pdf/test_helpers/pdf_reader_utils.rbs

@@ -0,0 +1,49 @@
+module Bidi2pdf
+  module TestHelpers
+    module PDFReaderUtils
+      # Extracts text content from a PDF document.
+      #
+      # This method accepts various PDF input formats and attempts to extract text content
+      # from all pages. If extraction fails due to malformed PDF data, it returns the original input.
+      #
+      # @param pdf_data [String, StringIO, File] The PDF data in one of the following formats:
+      #   * Base64-encoded PDF string
+      #   * Raw PDF data beginning with "%PDF-"
+      #   * StringIO object containing PDF data
+      #   * Path to a PDF file as String
+      #   * Raw PDF data as String
+      # @return [Array<String>] An array of strings, with each string representing the text content of a page
+      # @return [Object] The original input if PDF extraction fails
+      # @example Extract text from a PDF file
+      #   text_content = pdf_text('path/to/document.pdf')
+      #
+      # @example Extract text from Base64-encoded string
+      #   text_content = pdf_text(base64_encoded_pdf_data)
+      def self.pdf_text: (untyped pdf_data) -> untyped
+
+      # Converts the input PDF data into an IO object and initializes a PDF::Reader.
+      #
+      # @param pdf_data [String, StringIO, File] The PDF data to be read.
+      # @return [PDF::Reader] A PDF::Reader instance for the given data.
+      # @raise [PDF::Reader::MalformedPDFError] If the PDF data is invalid.
+      def self.pdf_reader_for: (untyped pdf_data) -> untyped
+
+      # rubocop: disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # Converts various input formats into an IO object for PDF::Reader.
+      #
+      # @param pdf_data [String, StringIO, File] The PDF data to be converted.
+      # @return [IO] An IO object containing the PDF data.
+      def self.convert_data_to_io: (untyped pdf_data) -> untyped
+
+      module InstanceMethods
+        def pdf_text: (untyped pdf_data) -> untyped
+
+        def pdf_reader_for: (untyped pdf_data) -> untyped
+
+        def convert_data_to_io: (untyped pdf_data) -> untyped
+      end
+
+      def self.included: (untyped base) -> untyped
+    end
+  end
+end