e621stream 0.0.0

data/sorbet/rbi/gems/async@2.46.0.rbi

@@ -0,0 +1,2193 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `async` gem.
+# Please instead update this file by running `bin/tapioca gem async`.
+
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2018-2026, by Samuel Williams.
+# Copyright, 2026, by Shopify Inc.
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+# @namespace
+# Released under the MIT License.
+# Copyright, 2025-2026, by Shopify Inc.
+# Copyright, 2025-2026, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2024-2025, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2022-2025, by Samuel Williams.
+# Copyright, 2025, by Shopify Inc.
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+# Released under the MIT License.
+# Copyright, 2022-2025, by Samuel Williams.
+# Copyright, 2024, by Patrik Wenger.
+# Copyright, 2025, by Shopify Inc.
+#
+# pkg:gem/async#lib/async/version.rb:7
+module Async; end
+
+# A general purpose synchronisation primitive, which allows one task to wait for a number of other tasks to complete. It can be used in conjunction with {Semaphore}.
+#
+# @public Since *Async v1*.
+#
+# pkg:gem/async#lib/async/barrier.rb:15
+class Async::Barrier
+  # Initialize the barrier.
+  # @parameter parent [Task | Semaphore | Nil] The parent for holding any children tasks.
+  # @public Since *Async v1*.
+  #
+  # pkg:gem/async#lib/async/barrier.rb:19
+  def initialize(parent: T.unsafe(nil)); end
+
+  # Execute a child task and add it to the barrier.
+  # @asynchronous Executes the given block concurrently.
+  # @returns [Task] The task which was created to execute the block.
+  #
+  # pkg:gem/async#lib/async/barrier.rb:48
+  def async(*arguments, parent: T.unsafe(nil), **options, &block); end
+
+  # Cancel all tasks held by the barrier.
+  # @asynchronous May wait for tasks to finish executing.
+  #
+  # pkg:gem/async#lib/async/barrier.rb:118
+  def cancel; end
+
+  # Whether there are any tasks being held by the barrier.
+  # @returns [Boolean]
+  #
+  # pkg:gem/async#lib/async/barrier.rb:77
+  def empty?; end
+
+  # Number of tasks being held by the barrier.
+  #
+  # pkg:gem/async#lib/async/barrier.rb:38
+  def size; end
+
+  # Backward compatibility alias for {#cancel}.
+  # @deprecated Use {#cancel} instead.
+  #
+  # pkg:gem/async#lib/async/barrier.rb:128
+  def stop; end
+
+  # All tasks which have been invoked into the barrier.
+  #
+  # pkg:gem/async#lib/async/barrier.rb:43
+  def tasks; end
+
+  # Wait for all tasks to complete by invoking {Task#wait} on each waiting task, which may raise an error. As long as the task has completed, it will be removed from the barrier.
+  #
+  # @yields {|task| ...} If a block is given, the unwaited task is yielded. You must invoke {Task#wait} yourself. In addition, you may `break` if you have captured enough results.
+  # @returns [Integer | Nil] The number of tasks which were waited for, or `nil` if there were no tasks to wait for.
+  #
+  # @asynchronous Will wait for tasks to finish executing.
+  #
+  # pkg:gem/async#lib/async/barrier.rb:87
+  def wait; end
+end
+
+# pkg:gem/async#lib/async/barrier.rb:27
+class Async::Barrier::TaskNode < ::Async::List::Node
+  # pkg:gem/async#lib/async/barrier.rb:28
+  def initialize(task); end
+
+  # pkg:gem/async#lib/async/barrier.rb:32
+  def task; end
+end
+
+# Raised when a task is explicitly cancelled.
+#
+# pkg:gem/async#lib/async/cancel.rb:8
+class Async::Cancel < ::Exception
+  # Create a new cancel operation.
+  #
+  # This is a compatibility method for Ruby versions before 3.5 where cause is not propagated correctly when using {Fiber#raise}
+  #
+  # @parameter message [String | Hash] The error message or a hash containing the cause.
+  #
+  # pkg:gem/async#lib/async/cancel.rb:40
+  def initialize(message = T.unsafe(nil)); end
+
+  # @returns [Exception] The cause of the cancel operation.
+  #
+  # This is a compatibility method for Ruby versions before 3.5 where cause is not propagated correctly when using {Fiber#raise}, we explicitly capture the cause here.
+  #
+  # pkg:gem/async#lib/async/cancel.rb:53
+  def cause; end
+end
+
+# Represents the source of the cancel operation.
+#
+# pkg:gem/async#lib/async/cancel.rb:10
+class Async::Cancel::Cause < ::Exception
+  class << self
+    # @returns [Array(String)] The backtrace of the caller.
+    # @returns [Array(Thread::Backtrace::Location)] The backtrace of the caller.
+    #
+    # pkg:gem/async#lib/async/cancel.rb:13
+    def backtrace; end
+
+    # Create a new cause of the cancel operation, with the given message.
+    #
+    # @parameter message [String] The error message.
+    # @returns [Cause] The cause of the cancel operation.
+    #
+    # pkg:gem/async#lib/async/cancel.rb:27
+    def for(message = T.unsafe(nil)); end
+  end
+end
+
+# Used to defer cancelling the current task until later.
+#
+# pkg:gem/async#lib/async/cancel.rb:59
+class Async::Cancel::Later
+  # Create a new cancel later operation.
+  #
+  # @parameter task [Task] The task to cancel later.
+  # @parameter cause [Exception] The cause of the cancel operation.
+  #
+  # pkg:gem/async#lib/async/cancel.rb:64
+  def initialize(task, cause = T.unsafe(nil)); end
+
+  # @returns [Boolean] Whether the task is alive.
+  #
+  # pkg:gem/async#lib/async/cancel.rb:70
+  def alive?; end
+
+  # Transfer control to the operation - this will cancel the task.
+  #
+  # pkg:gem/async#lib/async/cancel.rb:75
+  def transfer; end
+end
+
+# A list of children tasks.
+#
+# pkg:gem/async#lib/async/node.rb:16
+class Async::Children < ::Async::List
+  # Create an empty list of children tasks.
+  #
+  # pkg:gem/async#lib/async/node.rb:18
+  def initialize; end
+
+  # Adjust the number of transient children, assuming it has changed.
+  #
+  # Despite being public, this is not intended to be called directly. It is used internally by {Node#transient=}.
+  #
+  # @parameter transient [Boolean] Whether to increment or decrement the transient count.
+  #
+  # pkg:gem/async#lib/async/node.rb:44
+  def adjust_transient_count(transient); end
+
+  # Whether all children are considered finished. Ignores transient children.
+  #
+  # pkg:gem/async#lib/async/node.rb:30
+  def finished?; end
+
+  # Whether the children is empty, preserved for compatibility.
+  #
+  # pkg:gem/async#lib/async/node.rb:35
+  def nil?; end
+
+  # Some children may be marked as transient. Transient children do not prevent the parent from finishing.
+  # @returns [Boolean] Whether the node has transient children.
+  #
+  # pkg:gem/async#lib/async/node.rb:25
+  def transients?; end
+
+  private
+
+  # pkg:gem/async#lib/async/node.rb:54
+  def added(node); end
+
+  # pkg:gem/async#lib/async/node.rb:62
+  def removed(node); end
+end
+
+# A convenient wrapper around the internal monotonic clock.
+# @public Since *Async v1*.
+#
+# pkg:gem/async#lib/async/clock.rb:10
+class Async::Clock
+  # Create a new clock with the initial total time.
+  # @parameter total [Numeric] The initial clock duration.
+  #
+  # pkg:gem/async#lib/async/clock.rb:35
+  def initialize(total = T.unsafe(nil)); end
+
+  # Convert the clock to a JSON-compatible hash.
+  #
+  # @returns [Hash] The JSON-compatible hash.
+  #
+  # pkg:gem/async#lib/async/clock.rb:81
+  def as_json(*, **, &); end
+
+  # Reset the total elapsed time. If the clock is currently running, reset the start time to now.
+  #
+  # pkg:gem/async#lib/async/clock.rb:70
+  def reset!; end
+
+  # Start measuring a duration.
+  #
+  # pkg:gem/async#lib/async/clock.rb:44
+  def start!; end
+
+  # @returns [Numeric | Nil] The time when the clock was started, or nil if not started.
+  #
+  # pkg:gem/async#lib/async/clock.rb:41
+  def started; end
+
+  # Stop measuring a duration and append the duration to the current total.
+  #
+  # pkg:gem/async#lib/async/clock.rb:49
+  def stop!; end
+
+  # Convert the clock to a JSON string.
+  #
+  # @returns [String] The JSON string.
+  #
+  # pkg:gem/async#lib/async/clock.rb:91
+  def to_json(*, **, &); end
+
+  # The total elapsed time including any current duration.
+  #
+  # pkg:gem/async#lib/async/clock.rb:59
+  def total; end
+
+  class << self
+    # Measure the execution of a block of code.
+    # @yields {...} The block to execute.
+    # @returns [Numeric] The total execution time.
+    #
+    # pkg:gem/async#lib/async/clock.rb:19
+    def measure; end
+
+    # Get the current elapsed monotonic time.
+    #
+    # pkg:gem/async#lib/async/clock.rb:12
+    def now; end
+
+    # Start measuring elapsed time from now.
+    # @returns [Clock]
+    #
+    # pkg:gem/async#lib/async/clock.rb:29
+    def start; end
+  end
+end
+
+# A synchronization primitive, which allows fibers to wait until a particular condition is (edge) triggered.
+# @public Since *Async v1*.
+#
+# pkg:gem/async#lib/async/condition.rb:14
+class Async::Condition
+  # Create a new condition.
+  #
+  # pkg:gem/async#lib/async/condition.rb:16
+  def initialize; end
+
+  # @returns [Boolean] If there are no fibers waiting on this condition.
+  #
+  # pkg:gem/async#lib/async/condition.rb:27
+  def empty?; end
+
+  # Signal to a given task that it should resume operations.
+  # @parameter value [Object | Nil] The value to return to the waiting fibers.
+  #
+  # pkg:gem/async#lib/async/condition.rb:43
+  def signal(value = T.unsafe(nil)); end
+
+  # Queue up the current fiber and wait on yielding the task.
+  # @returns [Object]
+  #
+  # pkg:gem/async#lib/async/condition.rb:22
+  def wait; end
+
+  # @returns [Boolean] Is any fiber waiting on this notification?
+  #
+  # pkg:gem/async#lib/async/condition.rb:32
+  def waiting?; end
+
+  # @returns [Integer] Number of fibers waiting on this condition.
+  #
+  # pkg:gem/async#lib/async/condition.rb:37
+  def waiting_count; end
+
+  protected
+
+  # pkg:gem/async#lib/async/condition.rb:59
+  def exchange; end
+end
+
+# Represents a deadline timeout with decrementing remaining time.
+# Includes an efficient representation for zero (non-blocking) timeouts.
+# @public Since *Async v2.31*.
+#
+# pkg:gem/async#lib/async/deadline.rb:14
+class Async::Deadline
+  # Create a new deadline with the specified remaining time.
+  # @parameter remaining [Numeric] The initial remaining time.
+  #
+  # pkg:gem/async#lib/async/deadline.rb:46
+  def initialize(remaining); end
+
+  # Check if the deadline has expired.
+  # @returns [Boolean] True if no time remains.
+  #
+  # pkg:gem/async#lib/async/deadline.rb:67
+  def expired?; end
+
+  # Get the remaining time, updating internal state.
+  # Each call to this method advances the internal clock and reduces
+  # the remaining time by the elapsed duration since the last call.
+  # @returns [Numeric] The remaining time (may be negative if expired).
+  #
+  # pkg:gem/async#lib/async/deadline.rb:55
+  def remaining; end
+
+  class << self
+    # Create a deadline for the given timeout.
+    # @parameter timeout [Numeric | Nil] The timeout duration, or nil for no timeout.
+    # @returns [Deadline | Nil] A deadline instance, Zero singleton, or nil.
+    #
+    # pkg:gem/async#lib/async/deadline.rb:34
+    def start(timeout); end
+  end
+end
+
+# Singleton module for immediate timeouts (zero or negative).
+# Avoids object allocation for fast path (non-blocking) timeouts.
+#
+# pkg:gem/async#lib/async/deadline.rb:17
+module Async::Deadline::Zero
+  class << self
+    # Check if the deadline has expired.
+    # @returns [Boolean] Always returns true since zero timeouts are immediately expired.
+    #
+    # pkg:gem/async#lib/async/deadline.rb:20
+    def expired?; end
+
+    # Get the remaining time.
+    # @returns [Integer] Always returns 0 since zero timeouts have no remaining time.
+    #
+    # pkg:gem/async#lib/async/deadline.rb:26
+    def remaining; end
+  end
+end
+
+# Private module that hooks into Process._fork to handle fork events.
+#
+# If `Scheduler#process_fork` hook is adopted in Ruby 4, this code can be removed after Ruby < 4 is no longer supported.
+#
+# pkg:gem/async#lib/async/fork_handler.rb:11
+module Async::ForkHandler
+  # pkg:gem/async#lib/async/fork_handler.rb:12
+  def _fork(&block); end
+end
+
+# A load balancing mechanism that can be used process work when the system is idle.
+#
+# pkg:gem/async#lib/async/idler.rb:8
+class Async::Idler
+  # Create a new idler.
+  #
+  # @public Since *Async v2*.
+  #
+  # @parameter maximum_load [Numeric] The maximum load before we start shedding work.
+  # @parameter backoff [Numeric] The initial backoff time, used for delaying work.
+  # @parameter parent [Interface(:async) | Nil] The parent task to use for async operations.
+  #
+  # pkg:gem/async#lib/async/idler.rb:16
+  def initialize(maximum_load = T.unsafe(nil), backoff: T.unsafe(nil), parent: T.unsafe(nil)); end
+
+  # Wait until the system is idle, then execute the given block in a new task.
+  #
+  # @asynchronous Executes the given block concurrently.
+  #
+  # @parameter arguments [Array] The arguments to pass to the block.
+  # @parameter parent [Interface(:async) | Nil] The parent task to use for async operations.
+  # @parameter options [Hash] The options to pass to the task.
+  # @yields {|task| ...} When the system is idle, the block will be executed in a new task.
+  #
+  # pkg:gem/async#lib/async/idler.rb:33
+  def async(*arguments, parent: T.unsafe(nil), **options, &block); end
+
+  # Wait until the system is idle, according to the maximum load specified.
+  #
+  # If the scheduler is overloaded, this method will sleep for an exponentially increasing amount of time.
+  #
+  # pkg:gem/async#lib/async/idler.rb:43
+  def wait; end
+end
+
+# A thread-safe queue which limits the number of items that can be enqueued.
+#
+# @public Since *Async v1*.
+#
+# pkg:gem/async#lib/async/queue.rb:129
+class Async::LimitedQueue < ::Async::Queue
+  # Create a new limited queue.
+  #
+  # @parameter limit [Integer] The maximum number of items that can be enqueued.
+  # @parameter full [Notification] The notification to use for signaling when the queue is full. (ignored, for compatibility)
+  #
+  # pkg:gem/async#lib/async/queue.rb:141
+  def initialize(limit = T.unsafe(nil), **options); end
+
+  # @attribute [Integer] The maximum number of items that can be enqueued.
+  #
+  # pkg:gem/async#lib/async/queue.rb:146
+  def limit; end
+
+  # @returns [Boolean] Whether trying to enqueue an item would block.
+  #
+  # pkg:gem/async#lib/async/queue.rb:151
+  def limited?; end
+
+  class << self
+    # @private This exists purely for emitting a warning.
+    #
+    # pkg:gem/async#lib/async/queue.rb:131
+    def new(*, **, &); end
+  end
+end
+
+# A general doublely linked list. This is used internally by {Async::Barrier} and {Async::Condition} to manage child tasks.
+#
+# pkg:gem/async#lib/async/list.rb:9
+class Async::List
+  # Initialize a new, empty, list.
+  #
+  # pkg:gem/async#lib/async/list.rb:11
+  def initialize; end
+
+  # A callback that is invoked when an item is added to the list.
+  #
+  # pkg:gem/async#lib/async/list.rb:51
+  def added(node); end
+
+  # Append a node to the end of the list.
+  #
+  # pkg:gem/async#lib/async/list.rb:57
+  def append(node); end
+
+  # Iterate over each node in the linked list. It is generally safe to remove the current node, any previous node or any future node during iteration.
+  #
+  # @yields {|node| ...} Yields each node in the list.
+  # @returns [List] Returns self.
+  #
+  # pkg:gem/async#lib/async/list.rb:177
+  def each(&block); end
+
+  # @returns [Boolean] True if the list is empty.
+  #
+  # pkg:gem/async#lib/async/list.rb:140
+  def empty?; end
+
+  # @returns [Node] Returns the first node in the list, if it is not empty.
+  #
+  # pkg:gem/async#lib/async/list.rb:198
+  def first; end
+
+  # @attribute [Node | Nil] Points at the end of the list.
+  #
+  # pkg:gem/async#lib/async/list.rb:42
+  def head; end
+
+  # @attribute [Node | Nil] Points at the end of the list.
+  #
+  # pkg:gem/async#lib/async/list.rb:42
+  def head=(_arg0); end
+
+  # Determine whether the given node is included in the list.
+  #
+  # @parameter needle [Node] The node to search for.
+  # @returns [Boolean] Returns true if the node is in the list.
+  #
+  # pkg:gem/async#lib/async/list.rb:189
+  def include?(needle); end
+
+  # @returns [String] A short summary of the list.
+  #
+  # pkg:gem/async#lib/async/list.rb:23
+  def inspect; end
+
+  # @returns [Node] Returns the last node in the list, if it is not empty.
+  #
+  # pkg:gem/async#lib/async/list.rb:215
+  def last; end
+
+  # Prepend a node to the start of the list.
+  #
+  # pkg:gem/async#lib/async/list.rb:71
+  def prepend(node); end
+
+  # Remove the node. If it was already removed, this will raise an error.
+  #
+  # You should be careful to only remove nodes that are part of this list.
+  #
+  # @raises [ArgumentError] If the node is not part of this list.
+  # @returns [Node] Returns the node if it was removed, otherwise nil.
+  #
+  # pkg:gem/async#lib/async/list.rb:119
+  def remove(node); end
+
+  # Remove the node if it is in a list.
+  #
+  # You should be careful to only remove nodes that are part of this list.
+  #
+  # @returns [Node] Returns the node if it was removed, otherwise nil.
+  #
+  # pkg:gem/async#lib/async/list.rb:105
+  def remove?(node); end
+
+  # A callback that is invoked when an item is removed from the list.
+  #
+  # pkg:gem/async#lib/async/list.rb:95
+  def removed(node); end
+
+  # Shift the first node off the list, if it is not empty.
+  #
+  # pkg:gem/async#lib/async/list.rb:232
+  def shift; end
+
+  # @attribute [Integer] The number of nodes in the list.
+  #
+  # pkg:gem/async#lib/async/list.rb:48
+  def size; end
+
+  # Add the node, yield, and the remove the node.
+  # @yields {|node| ...} Yields the node.
+  # @returns [Object] Returns the result of the block.
+  #
+  # pkg:gem/async#lib/async/list.rb:87
+  def stack(node, &block); end
+
+  # @attribute [Node | Nil] Points at the start of the list.
+  #
+  # pkg:gem/async#lib/async/list.rb:45
+  def tail; end
+
+  # @attribute [Node | Nil] Points at the start of the list.
+  #
+  # pkg:gem/async#lib/async/list.rb:45
+  def tail=(_arg0); end
+
+  # Fast, safe, unbounded accumulation of children.
+  #
+  # pkg:gem/async#lib/async/list.rb:26
+  def to_a; end
+
+  # @returns [String] A short summary of the list.
+  #
+  # pkg:gem/async#lib/async/list.rb:18
+  def to_s; end
+
+  private
+
+  # pkg:gem/async#lib/async/list.rb:128
+  def remove!(node); end
+end
+
+# pkg:gem/async#lib/async/list.rb:252
+class Async::List::Iterator < ::Async::List::Node
+  # pkg:gem/async#lib/async/list.rb:253
+  def initialize(list); end
+
+  # pkg:gem/async#lib/async/list.rb:296
+  def each; end
+
+  # pkg:gem/async#lib/async/list.rb:281
+  def move_current; end
+
+  # pkg:gem/async#lib/async/list.rb:271
+  def move_next; end
+
+  # pkg:gem/async#lib/async/list.rb:263
+  def remove!; end
+
+  class << self
+    # pkg:gem/async#lib/async/list.rb:306
+    def each(list, &block); end
+  end
+end
+
+# A linked list Node.
+#
+# pkg:gem/async#lib/async/list.rb:239
+class Async::List::Node
+  # pkg:gem/async#lib/async/list.rb:240
+  def head; end
+
+  # pkg:gem/async#lib/async/list.rb:240
+  def head=(_arg0); end
+
+  # @returns [String] A string representation of the node.
+  #
+  # pkg:gem/async#lib/async/list.rb:249
+  def inspect; end
+
+  # pkg:gem/async#lib/async/list.rb:241
+  def tail; end
+
+  # pkg:gem/async#lib/async/list.rb:241
+  def tail=(_arg0); end
+
+  # @returns [String] A string representation of the node.
+  #
+  # pkg:gem/async#lib/async/list.rb:244
+  def to_s; end
+end
+
+# @namespace
+#
+# pkg:gem/async#lib/async/loop.rb:10
+module Async::Loop
+  class << self
+    # Execute a block repeatedly with a fixed delay between executions.
+    #
+    # Unlike {quantized}, this method waits for the specified interval *after* each execution
+    # completes. This means the actual time between the start of successive executions will be
+    # `interval + execution_time`.
+    #
+    # If an error occurs during block execution, it is logged and the loop continues.
+    #
+    # @example Run every 5 seconds (plus execution time):
+    # 	Async::Loop.periodic(interval: 5) do
+    # 		process_queue
+    # 	end
+    #
+    # @parameter interval [Numeric] The delay in seconds between executions.
+    # @yields The block to execute periodically.
+    #
+    # @public Since *Async v2.37*.
+    #
+    # pkg:gem/async#lib/async/loop.rb:72
+    def periodic(interval: T.unsafe(nil), &block); end
+
+    # Execute a block repeatedly at quantized (time-aligned) intervals.
+    #
+    # The alignment is computed modulo the current clock time in seconds. For example, with
+    # `interval: 60`, executions will occur at 00:00, 01:00, 02:00, etc., regardless of when
+    # the loop is started. With `interval: 300` (5 minutes), executions align to 00:00, 00:05,
+    # 00:10, etc.
+    #
+    # This is particularly useful for tasks that should run at predictable wall-clock times,
+    # such as metrics collection, periodic cleanup, or scheduled jobs that need to align
+    # across multiple processes.
+    #
+    # If an error occurs during block execution, it is logged and the loop continues.
+    #
+    # @example Run every minute at :00 seconds:
+    # 	Async::Loop.quantized(interval: 60) do
+    # 		puts "Current time: #{Time.now}"
+    # 	end
+    #
+    # @example Run every 5 minutes aligned to the hour:
+    # 	Async::Loop.quantized(interval: 300) do
+    # 		collect_metrics
+    # 	end
+    #
+    # @parameter interval [Numeric] The interval in seconds. Executions will align to multiples of this interval based on the current time.
+    # @yields The block to execute at each interval.
+    #
+    # @public Since *Async v2.37*.
+    #
+    # pkg:gem/async#lib/async/loop.rb:38
+    def quantized(interval: T.unsafe(nil), &block); end
+  end
+end
+
+# A node in a tree, used for implementing the task hierarchy.
+#
+# pkg:gem/async#lib/async/node.rb:72
+class Async::Node
+  # Create a new node in the tree.
+  # @parameter parent [Node | Nil] This node will attach to the given parent.
+  #
+  # pkg:gem/async#lib/async/node.rb:75
+  def initialize(parent = T.unsafe(nil), annotation: T.unsafe(nil), transient: T.unsafe(nil)); end
+
+  # Annotate the node with a description.
+  #
+  # @parameter annotation [String] The description to annotate the node with.
+  #
+  # pkg:gem/async#lib/async/node.rb:144
+  def annotate(annotation); end
+
+  # @attribute [String | Nil] A useful identifier for the current node.
+  #
+  # pkg:gem/async#lib/async/node.rb:110
+  def annotation; end
+
+  # Provides a backtrace for nodes that have an active execution context.
+  #
+  # @returns [Array(Thread::Backtrace::Locations) | Nil] The backtrace of the node, if available.
+  #
+  # pkg:gem/async#lib/async/node.rb:176
+  def backtrace(*arguments); end
+
+  # Attempt to cancel the current node immediately, including all non-transient children. Invokes {#stop_children} to cancel all children.
+  #
+  # @parameter later [Boolean] Whether to defer cancelling until some point in the future.
+  # @parameter cause [Exception | Nil] The cause of the cancel operation.
+  #
+  # pkg:gem/async#lib/async/node.rb:288
+  def cancel(later = T.unsafe(nil), cause: T.unsafe(nil)); end
+
+  # Whether the node has been cancelled.
+  #
+  # pkg:gem/async#lib/async/node.rb:313
+  def cancelled?; end
+
+  # @attribute [Children | Nil] Optional list of children.
+  #
+  # pkg:gem/async#lib/async/node.rb:107
+  def children; end
+
+  # Whether this node has any children.
+  # @returns [Boolean]
+  #
+  # pkg:gem/async#lib/async/node.rb:114
+  def children?; end
+
+  # If the node has a parent, and is {finished?}, then remove this node from
+  # the parent.
+  #
+  # pkg:gem/async#lib/async/node.rb:232
+  def consume; end
+
+  # A description of the node, including the annotation and object name.
+  #
+  # @returns [String] The description of the node.
+  #
+  # pkg:gem/async#lib/async/node.rb:161
+  def description; end
+
+  # Whether the node can be consumed (deleted) safely. By default, checks if the children set is empty.
+  #
+  # @returns [Boolean]
+  #
+  # pkg:gem/async#lib/async/node.rb:226
+  def finished?; end
+
+  # @private
+  #
+  # pkg:gem/async#lib/async/node.rb:98
+  def head; end
+
+  # @private
+  #
+  # pkg:gem/async#lib/async/node.rb:98
+  def head=(_arg0); end
+
+  # @returns [String] A description of the node.
+  #
+  # pkg:gem/async#lib/async/node.rb:186
+  def inspect; end
+
+  # @attribute [Node] The parent node.
+  #
+  # pkg:gem/async#lib/async/node.rb:104
+  def parent; end
+
+  # Change the parent of this node.
+  #
+  # @parameter parent [Node | Nil] The parent to attach to, or nil to detach.
+  # @returns [Node] Itself.
+  #
+  # pkg:gem/async#lib/async/node.rb:192
+  def parent=(parent); end
+
+  # Print the hierarchy of the task tree from the given node.
+  #
+  # @parameter out [IO] The output stream to write to.
+  # @parameter backtrace [Boolean] Whether to print the backtrace of each node.
+  #
+  # pkg:gem/async#lib/async/node.rb:327
+  def print_hierarchy(out = T.unsafe(nil), backtrace: T.unsafe(nil)); end
+
+  # @returns [Node] The root node in the hierarchy.
+  #
+  # pkg:gem/async#lib/async/node.rb:93
+  def root; end
+
+  # Backward compatibility alias for {#cancel}.
+  # @deprecated Use {#cancel} instead.
+  #
+  # pkg:gem/async#lib/async/node.rb:295
+  def stop(*, **, &); end
+
+  # Backward compatibility alias for {#cancelled?}.
+  # @deprecated Use {#cancelled?} instead.
+  #
+  # pkg:gem/async#lib/async/node.rb:319
+  def stopped?; end
+
+  # @private
+  #
+  # pkg:gem/async#lib/async/node.rb:101
+  def tail; end
+
+  # @private
+  #
+  # pkg:gem/async#lib/async/node.rb:101
+  def tail=(_arg0); end
+
+  # Immediately terminate all children tasks, including transient tasks. Internally invokes `stop(false)` on all children. This should be considered a last ditch effort and is used when closing the scheduler.
+  #
+  # pkg:gem/async#lib/async/node.rb:272
+  def terminate; end
+
+  # @returns [String] A description of the node.
+  #
+  # pkg:gem/async#lib/async/node.rb:181
+  def to_s; end
+
+  # Change the transient state of the node.
+  #
+  # A transient node is not considered when determining if a node is finished, and propagates up if the parent is consumed.
+  #
+  # @parameter value [Boolean] Whether the node is transient.
+  #
+  # pkg:gem/async#lib/async/node.rb:133
+  def transient=(value); end
+
+  # Represents whether a node is transient. Transient nodes are not considered
+  # when determining if a node is finished. This is useful for tasks which are
+  # internal to an object rather than explicit user concurrency. For example,
+  # a child task which is pruning a connection pool is transient, because it
+  # is not directly related to the parent task, and should not prevent the
+  # parent task from finishing.
+  #
+  # pkg:gem/async#lib/async/node.rb:124
+  def transient?; end
+
+  # Traverse the task tree.
+  #
+  # @returns [Enumerator] An enumerator which will traverse the tree if no block is given.
+  # @yields {|node, level| ...} The node and the level relative to the given root.
+  #
+  # pkg:gem/async#lib/async/node.rb:257
+  def traverse(&block); end
+
+  # Wait for this node to complete. By default, nodes cannot be waited on.
+  # Subclasses like Task override this method to provide waiting functionality.
+  #
+  # pkg:gem/async#lib/async/node.rb:308
+  def wait; end
+
+  protected
+
+  # pkg:gem/async#lib/async/node.rb:211
+  def add_child(child); end
+
+  # pkg:gem/async#lib/async/node.rb:217
+  def remove_child(child); end
+
+  # pkg:gem/async#lib/async/node.rb:207
+  def set_parent(parent); end
+
+  # pkg:gem/async#lib/async/node.rb:263
+  def traverse_recurse(level = T.unsafe(nil), &block); end
+
+  private
+
+  # pkg:gem/async#lib/async/node.rb:339
+  def print_backtrace(out, indent, node); end
+
+  # Attempt to stop all non-transient children.
+  #
+  # pkg:gem/async#lib/async/node.rb:300
+  def stop_children(later = T.unsafe(nil), cause:); end
+end
+
+# A synchronization primitive, which allows fibers to wait until a notification is received. Does not block the task which signals the notification. Waiting tasks are resumed on next iteration of the reactor.
+# @public Since *Async v1*.
+#
+# pkg:gem/async#lib/async/notification.rb:11
+class Async::Notification < ::Async::Condition
+  # Signal to a given task that it should resume operations.
+  #
+  # @returns [Boolean] if a task was signalled.
+  #
+  # pkg:gem/async#lib/async/notification.rb:15
+  def signal(value = T.unsafe(nil)); end
+end
+
+# pkg:gem/async#lib/async/notification.rb:23
+class Async::Notification::Signal < ::Struct
+  # pkg:gem/async#lib/async/notification.rb:24
+  def alive?; end
+
+  # pkg:gem/async#lib/async/notification.rb:23
+  def ready; end
+
+  # pkg:gem/async#lib/async/notification.rb:23
+  def ready=(_); end
+
+  # pkg:gem/async#lib/async/notification.rb:28
+  def transfer; end
+
+  # pkg:gem/async#lib/async/notification.rb:23
+  def value; end
+
+  # pkg:gem/async#lib/async/notification.rb:23
+  def value=(_); end
+
+  class << self
+    # pkg:gem/async#lib/async/notification.rb:23
+    def [](*_arg0); end
+
+    # pkg:gem/async#lib/async/notification.rb:23
+    def inspect; end
+
+    # pkg:gem/async#lib/async/notification.rb:23
+    def keyword_init?; end
+
+    # pkg:gem/async#lib/async/notification.rb:23
+    def members; end
+
+    # pkg:gem/async#lib/async/notification.rb:23
+    def new(*_arg0); end
+  end
+end
+
+# Fiber::Profiler is not available.
+#
+# pkg:gem/async#lib/async/scheduler.rb:26
+Async::Profiler = T.let(T.unsafe(nil), T.untyped)
+
+# A promise represents a value that will be available in the future.
+# Unlike Condition, once resolved (or rejected), all future waits return immediately
+# with the stored value or raise the stored exception.
+#
+# This is thread-safe and integrates with the fiber scheduler.
+#
+# @public Since *Async v2*.
+#
+# pkg:gem/async#lib/async/promise.rb:20
+class Async::Promise
+  # Create a new promise.
+  #
+  # pkg:gem/async#lib/async/promise.rb:22
+  def initialize; end
+
+  # Cancel the promise, indicating cancellation.
+  # All current and future waiters will receive nil.
+  # Can only be called on pending promises - no-op if already resolved.
+  #
+  # pkg:gem/async#lib/async/promise.rb:214
+  def cancel(exception = T.unsafe(nil)); end
+
+  # @returns [Boolean] Whether the promise has been cancelled.
+  #
+  # pkg:gem/async#lib/async/promise.rb:48
+  def cancelled?; end
+
+  # @returns [Boolean] Whether the promise has completed successfully.
+  #
+  # pkg:gem/async#lib/async/promise.rb:58
+  def completed?; end
+
+  # @returns [Boolean] Whether the promise failed with an exception.
+  #
+  # pkg:gem/async#lib/async/promise.rb:53
+  def failed?; end
+
+  # Resolve the promise with the result of the block.
+  # If the block raises an exception, the promise will be rejected.
+  # If the promise was already resolved, the block will not be called.
+  # @yields {...} The block to call to resolve the promise.
+  # @returns [Object] The result of the block.
+  #
+  # pkg:gem/async#lib/async/promise.rb:234
+  def fulfill(&block); end
+
+  # Reject the promise with an exception.
+  # All current and future waiters will receive this exception.
+  # Can only be called once - subsequent calls are ignored.
+  #
+  # @parameter exception [Exception] The exception to reject the promise with.
+  #
+  # pkg:gem/async#lib/async/promise.rb:197
+  def reject(exception); end
+
+  # Resolve the promise with a value.
+  # All current and future waiters will receive this value.
+  # Can only be called once - subsequent calls are ignored.
+  #
+  # @parameter value [Object] The value to resolve the promise with.
+  #
+  # pkg:gem/async#lib/async/promise.rb:178
+  def resolve(value); end
+
+  # @returns [Symbol | Nil] The internal resolved state (:completed, :failed, :cancelled, or nil if pending).
+  # @private For internal use by Task.
+  #
+  # pkg:gem/async#lib/async/promise.rb:43
+  def resolved; end
+
+  # @returns [Boolean] Whether the promise has been resolved or rejected.
+  #
+  # pkg:gem/async#lib/async/promise.rb:37
+  def resolved?; end
+
+  # Artificially mark that someone is waiting (useful for suppressing warnings).
+  # @private Internal use only.
+  #
+  # pkg:gem/async#lib/async/promise.rb:69
+  def suppress_warnings!; end
+
+  # Non-blocking access to the current value. Returns nil if not yet resolved.
+  # Does not raise exceptions even if the promise was rejected or cancelled.
+  # For resolved promises, returns the raw stored value (result, exception, or cancel exception).
+  #
+  # @returns [Object | Nil] The stored value, or nil if pending.
+  #
+  # pkg:gem/async#lib/async/promise.rb:78
+  def value; end
+
+  # Wait for the promise to be resolved and return the value.
+  #
+  # If already resolved, returns immediately. If rejected, raises the stored exception.
+  #
+  # @returns [Object] The resolved value.
+  # @raises [Exception] The rejected or cancelled exception.
+  # @raises [Async::TimeoutError] If timeout expires before the promise is resolved.
+  #
+  # pkg:gem/async#lib/async/promise.rb:160
+  def wait(*, **, &); end
+
+  # Wait for the promise to be resolved (without raising exceptions).
+  #
+  # If already resolved, returns immediately. Otherwise, waits until resolution or timeout.
+  #
+  # @parameter timeout [Numeric | Nil] Maximum time to wait. If nil, waits indefinitely. If 0, returns immediately if not resolved.
+  # @returns [Boolean] True if the promise is resolved, false if timeout expires
+  #
+  # pkg:gem/async#lib/async/promise.rb:125
+  def wait?(timeout: T.unsafe(nil)); end
+
+  # @returns [Boolean] Whether any fibers are currently waiting for this promise.
+  #
+  # pkg:gem/async#lib/async/promise.rb:63
+  def waiting?; end
+
+  private
+
+  # Wait indefinitely for the promise to be resolved.
+  #
+  # pkg:gem/async#lib/async/promise.rb:83
+  def wait_indefinitely; end
+
+  # Wait for the promise to be resolved, respecting the deadline timeout.
+  # @parameter timeout [Numeric] The timeout duration.
+  # @returns [Boolean] True if resolved, false if timeout expires.
+  #
+  # pkg:gem/async#lib/async/promise.rb:92
+  def wait_with_timeout(timeout); end
+
+  class << self
+    # If a promise is given, fulfill it with the result of the block.
+    # If no promise is given, simply yield to the block.
+    # This is useful for methods that may optionally take a promise to fulfill.
+    # @parameter promise [Promise | Nil] The optional promise to fulfill.
+    # @yields {...} The block to call to resolve the promise or return a value.
+    # @returns [Object] The result of the block.
+    #
+    # pkg:gem/async#lib/async/promise.rb:258
+    def fulfill(promise, &block); end
+  end
+end
+
+# A thread-safe queue which allows items to be processed in order.
+#
+# This implementation uses Thread::Queue internally for thread safety while
+# maintaining compatibility with the fiber scheduler.
+#
+# It has a compatible interface with {Notification} and {Condition}, except that it's multi-value.
+#
+# @asynchronous This class is thread-safe.
+# @public Since *Async v1*.
+#
+# pkg:gem/async#lib/async/queue.rb:22
+class Async::Queue
+  # Create a new thread-safe queue.
+  #
+  # @parameter parent [Interface(:async) | Nil] The parent task to use for async operations.
+  #
+  # pkg:gem/async#lib/async/queue.rb:31
+  def initialize(parent: T.unsafe(nil), delegate: T.unsafe(nil)); end
+
+  # Compatibility with {::Queue#push}.
+  #
+  # pkg:gem/async#lib/async/queue.rb:69
+  def <<(item); end
+
+  # Process each item in the queue.
+  #
+  # @asynchronous Executes the given block concurrently for each item.
+  #
+  # @parameter arguments [Array] The arguments to pass to the block.
+  # @parameter parent [Interface(:async) | Nil] The parent task to use for async operations.
+  # @parameter options [Hash] The options to pass to the task.
+  # @yields {|task| ...} When the system is idle, the block will be executed in a new task.
+  #
+  # pkg:gem/async#lib/async/queue.rb:102
+  def async(parent: T.unsafe(nil), **options, &block); end
+
+  # Close the queue, causing all waiting tasks to return `nil`. Any subsequent calls to {enqueue} will raise an exception.
+  #
+  # pkg:gem/async#lib/async/queue.rb:42
+  def close; end
+
+  # @returns [Boolean] Whether the queue is closed.
+  #
+  # pkg:gem/async#lib/async/queue.rb:37
+  def closed?; end
+
+  # Remove and return the next item from the queue.
+  # @parameter timeout [Numeric, nil] Maximum time to wait for an item. If nil, waits indefinitely. If 0, returns immediately.
+  # @returns [Object, nil] The dequeued item, or nil if timeout expires.
+  #
+  # pkg:gem/async#lib/async/queue.rb:83
+  def dequeue(timeout: T.unsafe(nil)); end
+
+  # Enumerate each item in the queue.
+  #
+  # pkg:gem/async#lib/async/queue.rb:109
+  def each; end
+
+  # @returns [Boolean] Whether the queue is empty.
+  #
+  # pkg:gem/async#lib/async/queue.rb:52
+  def empty?; end
+
+  # Add multiple items to the queue.
+  #
+  # pkg:gem/async#lib/async/queue.rb:74
+  def enqueue(*items); end
+
+  # Compatibility with {::Queue#pop}.
+  # @parameter timeout [Numeric, nil] Maximum time to wait for an item. If nil, waits indefinitely. If 0, returns immediately.
+  # @returns [Object, nil] The dequeued item, or nil if timeout expires.
+  #
+  # pkg:gem/async#lib/async/queue.rb:90
+  def pop(timeout: T.unsafe(nil)); end
+
+  # Add an item to the queue.
+  #
+  # pkg:gem/async#lib/async/queue.rb:62
+  def push(item); end
+
+  # Signal the queue with a value, the same as {#enqueue}.
+  #
+  # pkg:gem/async#lib/async/queue.rb:116
+  def signal(value = T.unsafe(nil)); end
+
+  # @returns [Integer] The number of items in the queue.
+  #
+  # pkg:gem/async#lib/async/queue.rb:47
+  def size; end
+
+  # Wait for an item to be available, the same as {#dequeue}.
+  #
+  # pkg:gem/async#lib/async/queue.rb:121
+  def wait; end
+
+  # @returns [Integer] The number of tasks waiting for an item.
+  #
+  # pkg:gem/async#lib/async/queue.rb:57
+  def waiting_count; end
+end
+
+# An error raised when trying to enqueue items to a closed queue.
+# @public Since *Async v2.24*.
+#
+# pkg:gem/async#lib/async/queue.rb:25
+class Async::Queue::ClosedError < ::RuntimeError; end
+
+# A wrapper around the the scheduler which binds it to the current thread automatically.
+#
+# pkg:gem/async#lib/async/reactor.rb:12
+class Async::Reactor < ::Async::Scheduler
+  # Initialize the reactor and assign it to the current Fiber scheduler.
+  #
+  # pkg:gem/async#lib/async/reactor.rb:21
+  def initialize(*, **, &); end
+
+  # Close the reactor and remove it from the current Fiber scheduler.
+  #
+  # pkg:gem/async#lib/async/reactor.rb:28
+  def scheduler_close; end
+
+  # pkg:gem/async#lib/async/reactor.rb:32
+  def sleep(*_arg0); end
+
+  class << self
+    # @deprecated Replaced by {Kernel::Async}.
+    #
+    # pkg:gem/async#lib/async/reactor.rb:14
+    def run(*, **, &); end
+  end
+end
+
+# Handles scheduling of fibers. Implements the fiber scheduler interface.
+#
+# pkg:gem/async#lib/async/scheduler.rb:30
+class Async::Scheduler < ::Async::Node
+  # Create a new scheduler.
+  #
+  # @public Since *Async v1*.
+  # @parameter parent [Node | Nil] The parent node to use for task hierarchy.
+  # @parameter selector [IO::Event::Selector] The selector to use for event handling.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:78
+  def initialize(parent = T.unsafe(nil), selector: T.unsafe(nil), profiler: T.unsafe(nil), worker_pool: T.unsafe(nil)); end
+
+  # Resolve the address of the given hostname.
+  #
+  # @public Since *Async v2*.
+  # @asynchronous May be non-blocking.
+  #
+  # @parameter hostname [String] The hostname to resolve.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:295
+  def address_resolve(hostname); end
+
+  # Start an asynchronous task within the specified reactor. The task will be executed until the first blocking call, at which point it will yield and and this method will return.
+  #
+  # @public Since *Async v1*.
+  # @asynchronous May context switch immediately to new task.
+  # @deprecated Use {#run} or {Task#async} instead.
+  #
+  # @yields {|task| ...} Executed within the task.
+  # @returns [Task] The task that was scheduled into the reactor.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:633
+  def async(*arguments, **options, &block); end
+
+  # Invoked when a fiber tries to perform a blocking operation which cannot continue. A corresponding call {unblock} must be performed to allow this fiber to continue.
+  #
+  # @public Since *Async v2*.
+  # @asynchronous May only be called on same thread as fiber scheduler.
+  #
+  # @parameter blocker [Object] The object that is blocking the fiber.
+  # @parameter timeout [Float | Nil] The maximum time to block, or if nil, indefinitely.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:234
+  def block(blocker, timeout); end
+
+  # Cancel all children, including transient children.
+  #
+  # @public Since *Async v1*.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:534
+  def cancel(later = T.unsafe(nil), cause: T.unsafe(nil)); end
+
+  # Terminate all child tasks and close the scheduler.
+  # @public Since *Async v1*.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:150
+  def close; end
+
+  # @returns [Boolean] Whether the scheduler has been closed.
+  # @public Since *Async v1*.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:177
+  def closed?; end
+
+  # Create a new fiber and return it without starting execution.
+  # @returns [Fiber] The fiber that was created.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:648
+  def fiber(*, **, &); end
+
+  # Raise an exception on the specified fiber, waking up the event loop if necessary.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:412
+  def fiber_interrupt(fiber, exception); end
+
+  # Interrupt the event loop and cause it to exit.
+  # @asynchronous May be called from any thread.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:188
+  def interrupt; end
+
+  # Read at most the specified number of bytes from the IO into the buffer.
+  #
+  # @public Since *Async v2* and Ruby with `IO::Buffer` support.
+  # @asynchronous May be non-blocking.
+  #
+  # @parameter io [IO] The IO object to read from.
+  # @parameter buffer [IO::Buffer] The buffer to read into.
+  # @parameter offset [Integer] The offset within the buffer to read into.
+  # @parameter length [Integer] The maximum number of bytes to read.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:349
+  def io_read(io, buffer, offset, length); end
+
+  # Wait for the specified IOs to become ready for the specified events.
+  #
+  # @public Since *Async v2.25*.
+  # @asynchronous May be non-blocking.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:441
+  def io_select(*, **, &); end
+
+  # Wait for the specified IO to become ready for the specified events.
+  #
+  # @public Since *Async v2*.
+  # @asynchronous May be non-blocking.
+  #
+  # @parameter io [IO] The IO object to wait on.
+  # @parameter events [Integer] The events to wait for, e.g. `IO::READABLE`, `IO::WRITABLE`, etc.
+  # @parameter timeout [Float | Nil] The maximum time to wait, or if nil, indefinitely.
+  # @returns [Integer | false] The subset of events that are ready, or `false` if the timeout expires.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:311
+  def io_wait(io, events, timeout = T.unsafe(nil)); end
+
+  # Write at most the specified number of bytes from the buffer to the IO.
+  #
+  # @public Since *Async v2* and *Ruby v3.3.1* with `IO::Buffer` support.
+  # @asynchronous May be non-blocking.
+  #
+  # @parameter io [IO] The IO object to write to.
+  # @parameter buffer [IO::Buffer] The buffer to write from.
+  # @parameter offset [Integer] The offset within the buffer to write from.
+  # @parameter length [Integer] The maximum number of bytes to write.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:373
+  def io_write(io, buffer, offset, length); end
+
+  # Sleep for the specified duration.
+  #
+  # @public Since *Async v2* and *Ruby v3.1*.
+  # @asynchronous May be non-blocking.
+  #
+  # @parameter duration [Numeric | Nil] The time in seconds to sleep, or if nil, indefinitely.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:279
+  def kernel_sleep(duration = T.unsafe(nil)); end
+
+  # Compute the scheduler load according to the busy and idle times that are updated by the run loop.
+  #
+  # @returns [Float] The load of the scheduler. 0.0 means no load, 1.0 means fully loaded or over-loaded.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:107
+  def load; end
+
+  # Handle fork in the child process. This method is called automatically when `Process.fork` is invoked on Ruby versions < 4 and cleans up the scheduler state. On Ruby 4+, the scheduler is automatically cleaned up by the Ruby runtime.
+  #
+  # The child process starts with a clean slate - no scheduler is set. Users can create a new scheduler if needed.
+  #
+  # @public Since *Async v2.35*.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:699
+  def process_fork; end
+
+  # Wait for the specified process ID to exit.
+  #
+  # @public Since *Async v2*.
+  # @asynchronous May be non-blocking.
+  #
+  # @parameter pid [Integer] The process ID to wait for.
+  # @parameter flags [Integer] A bit-mask of flags suitable for `Process::Status.wait`.
+  # @returns [Process::Status] A process status instance.
+  # @asynchronous May be non-blocking..
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:426
+  def process_wait(pid, flags); end
+
+  # Schedule a fiber (or equivalent object) to be resumed on the next loop through the reactor.
+  # @parameter fiber [Fiber | Object] The object to be resumed on the next iteration of the run-loop.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:205
+  def push(fiber); end
+
+  # Raise an exception on a specified fiber with the given arguments.
+  #
+  # This internally schedules the current fiber to be ready, before raising the exception, so that it will later resume execution.
+  #
+  # @parameter fiber [Fiber] The fiber to raise the exception on.
+  # @parameter *arguments [Array] The arguments to pass to the fiber.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:215
+  def raise(*, **, &); end
+
+  # Resume execution of the specified fiber.
+  #
+  # @parameter fiber [Fiber] The fiber to resume.
+  # @parameter arguments [Array] The arguments to pass to the fiber.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:223
+  def resume(fiber, *arguments); end
+
+  # Run the reactor until all tasks are finished. Proxies arguments to {#async} immediately before entering the loop, if a block is provided.
+  #
+  # Forwards all parameters to {#async} if a block is given.
+  #
+  # @public Since *Async v1*.
+  #
+  # @yields {|task| ...} The top level task, if a block is given.
+  # @returns [Task] The initial task that was scheduled into the reactor.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:601
+  def run(*, **, &); end
+
+  # Run one iteration of the event loop.
+  #
+  # @public Since *Async v1*.
+  # @asynchronous Must be invoked from blocking (root) fiber.
+  #
+  # @parameter timeout [Float | Nil] The maximum timeout, or if nil, indefinite.
+  # @returns [Boolean] Whether there is more work to do.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:500
+  def run_once(timeout = T.unsafe(nil)); end
+
+  # Invoked when the fiber scheduler is being closed.
+  #
+  # Executes the run loop until all tasks are finished, then closes the scheduler.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:129
+  def scheduler_close(error = T.unsafe(nil)); end
+
+  # Backward compatibility alias for cancel.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:545
+  def stop(*, **, &); end
+
+  # Terminate all child tasks.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:139
+  def terminate; end
+
+  # Invoke the block, but after the specified timeout, raise the specified exception with the given message. If the block runs to completion before the timeout occurs or there are no non-blocking operations after the timeout expires, the code will complete without any exception.
+  #
+  # @public Since *Async v1* and *Ruby v3.1*. May be invoked from `Timeout.timeout`.
+  # @asynchronous May raise an exception at any interruption point (e.g. blocking operations).
+  #
+  # @parameter duration [Numeric] The time in seconds, in which the task should complete.
+  # @parameter exception [Class] The exception class to raise.
+  # @parameter message [String] The message to pass to the exception.
+  # @yields {|duration| ...} The block to execute with a timeout.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:688
+  def timeout_after(duration, exception, message, &block); end
+
+  # @returns [String] A description of the scheduler.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:182
+  def to_s; end
+
+  # Transfer from the calling fiber to the event loop.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:194
+  def transfer; end
+
+  # Unblock a fiber that was previously blocked.
+  #
+  # @public Since *Async v2* and *Ruby v3.1*.
+  # @asynchronous May be called from any thread.
+  #
+  # @parameter blocker [Object] The object that was blocking the fiber.
+  # @parameter fiber [Fiber] The fiber to unblock.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:263
+  def unblock(blocker, fiber); end
+
+  # Invoke the block, but after the specified timeout, raise {TimeoutError} in any currenly blocking operation. If the block runs to completion before the timeout occurs or there are no non-blocking operations after the timeout expires, the code will complete without any exception.
+  #
+  # @public Since *Async v1*.
+  # @asynchronous May raise an exception at any interruption point (e.g. blocking operations).
+  #
+  # @parameter duration [Numeric] The time in seconds, in which the task should complete.
+  # @parameter exception [Class] The exception class to raise.
+  # @parameter message [String] The message to pass to the exception.
+  # @yields {|timeout| ...} The block to execute with a timeout.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:661
+  def with_timeout(duration, exception = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  # Yield the current fiber and resume it on the next iteration of the event loop.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:199
+  def yield; end
+
+  private
+
+  # Checks and clears the interrupted state of the scheduler.
+  #
+  # @returns [Boolean] Whether the reactor has been interrupted.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:518
+  def interrupted?; end
+
+  # Run the event loop, until the scheduler is interrupted or finished.
+  #
+  # @parameter initial [Proc | Nil] The initial block to execute before the first loop iteration.
+  # @yields {...} The block to execute on each loop iteration.
+  # @raises {Interrupt} If the scheduler is interrupted.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:554
+  def run_loop(initial = T.unsafe(nil), &block); end
+
+  # Run one iteration of the event loop.
+  #
+  # When terminating the event loop, we already know we are finished. So we don't need to check the task tree. This is a logical requirement because `run_once` ignores transient tasks. For example, a single top level transient task is not enough to keep the reactor running, but during termination we must still process it in order to terminate child tasks.
+  #
+  # @parameter timeout [Float | Nil] The maximum timeout, or if nil, indefinite.
+  # @returns [Boolean] Whether there is more work to do.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:456
+  def run_once!(timeout = T.unsafe(nil)); end
+
+  class << self
+    # Whether the fiber scheduler is supported.
+    # @public Since *Async v1*.
+    #
+    # pkg:gem/async#lib/async/scheduler.rb:47
+    def supported?; end
+  end
+end
+
+# Used to augment the scheduler to add support for blocking operations.
+#
+# pkg:gem/async#lib/async/scheduler.rb:52
+module Async::Scheduler::BlockingOperationWait
+  # Wait for the given work to be executed.
+  #
+  # @public Since *Async v2.21* and *Ruby v3.4*.
+  # @asynchronous May be non-blocking.
+  #
+  # @parameter work [Proc] The work to execute on a background thread.
+  # @returns [Object] The result of the work.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:60
+  def blocking_operation_wait(work); end
+end
+
+# Raised when an operation is attempted on a closed scheduler.
+#
+# pkg:gem/async#lib/async/scheduler.rb:36
+class Async::Scheduler::ClosedError < ::RuntimeError
+  # Create a new error.
+  #
+  # @parameter message [String] The error message.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:40
+  def initialize(message = T.unsafe(nil)); end
+end
+
+# Used to defer stopping the current task until later.
+#
+# pkg:gem/async#lib/async/scheduler.rb:390
+class Async::Scheduler::FiberInterrupt
+  # Create a new stop later operation.
+  #
+  # @parameter task [Task] The task to stop later.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:394
+  def initialize(fiber, exception); end
+
+  # @returns [Boolean] Whether the task is alive.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:400
+  def alive?; end
+
+  # Transfer control to the operation - this will stop the task.
+  #
+  # pkg:gem/async#lib/async/scheduler.rb:405
+  def transfer; end
+end
+
+# pkg:gem/async#lib/async/scheduler.rb:31
+Async::Scheduler::WORKER_POOL = T.let(T.unsafe(nil), T.untyped)
+
+# pkg:gem/async#lib/async/scheduler.rb:70
+Async::Scheduler::WorkerPool = T.let(T.unsafe(nil), T.untyped)
+
+# A synchronization primitive, which limits access to a given resource.
+# @public Since *Async v1*.
+#
+# pkg:gem/async#lib/async/semaphore.rb:11
+class Async::Semaphore
+  # @parameter limit [Integer] The maximum number of times the semaphore can be acquired before it blocks.
+  # @parameter parent [Task | Semaphore | Nil] The parent for holding any children tasks.
+  #
+  # pkg:gem/async#lib/async/semaphore.rb:14
+  def initialize(limit = T.unsafe(nil), parent: T.unsafe(nil)); end
+
+  # Acquire the semaphore, block if we are at the limit.
+  # If no block is provided, you must call release manually.
+  # @yields {...} When the semaphore can be acquired.
+  # @returns The result of the block if invoked.
+  #
+  # pkg:gem/async#lib/async/semaphore.rb:79
+  def acquire; end
+
+  # Run an async task. Will wait until the semaphore is ready until spawning and running the task.
+  #
+  # pkg:gem/async#lib/async/semaphore.rb:61
+  def async(*arguments, parent: T.unsafe(nil), **options); end
+
+  # Whether trying to acquire this semaphore would block.
+  #
+  # pkg:gem/async#lib/async/semaphore.rb:56
+  def blocking?; end
+
+  # The current number of tasks that have acquired the semaphore.
+  #
+  # pkg:gem/async#lib/async/semaphore.rb:23
+  def count; end
+
+  # Is the semaphore currently acquired?
+  #
+  # pkg:gem/async#lib/async/semaphore.rb:51
+  def empty?; end
+
+  # The maximum number of tasks that can acquire the semaphore.
+  #
+  # pkg:gem/async#lib/async/semaphore.rb:26
+  def limit; end
+
+  # Allow setting the limit. This is useful for cases where the semaphore is used to limit the number of concurrent tasks, but the number of tasks is not known in advance or needs to be modified.
+  #
+  # On increasing the limit, some tasks may be immediately resumed. On decreasing the limit, some tasks may execute until the count is < than the limit.
+  #
+  # @parameter limit [Integer] The new limit.
+  #
+  # pkg:gem/async#lib/async/semaphore.rb:36
+  def limit=(limit); end
+
+  # Release the semaphore. Must match up with a corresponding call to `acquire`. Will release waiting fibers in FIFO order.
+  #
+  # pkg:gem/async#lib/async/semaphore.rb:94
+  def release; end
+
+  # The tasks waiting on this semaphore.
+  #
+  # pkg:gem/async#lib/async/semaphore.rb:29
+  def waiting; end
+
+  private
+
+  # Wait until the semaphore becomes available.
+  #
+  # pkg:gem/async#lib/async/semaphore.rb:119
+  def wait; end
+end
+
+# pkg:gem/async#lib/async/semaphore.rb:104
+class Async::Semaphore::FiberNode < ::Async::List::Node
+  # pkg:gem/async#lib/async/semaphore.rb:105
+  def initialize(fiber); end
+
+  # pkg:gem/async#lib/async/semaphore.rb:109
+  def resume; end
+end
+
+# pkg:gem/async#lib/async/stop.rb:9
+Async::Stop = Async::Cancel
+
+# Represents a sequential unit of work, defined by a block, which is executed concurrently with other tasks. A task can be in one of the following states: `initialized`, `running`, `completed`, `failed`, or `cancelled`.
+#
+# ```mermaid
+# stateDiagram-v2
+# [*] --> Initialized
+# Initialized --> Running : Run
+#
+# Running --> Completed : Return Value
+# Running --> Failed : Exception
+#
+# Completed --> [*]
+# Failed --> [*]
+#
+# Running --> Cancelled : Cancel
+# Cancelled --> [*]
+# Completed --> Cancelled : Cancel
+# Failed --> Cancelled : Cancel
+# Initialized --> Cancelled : Cancel
+# ```
+#
+# @example Creating a task that sleeps for 1 second.
+# 	require "async"
+# 	Async do |task|
+# 		sleep(1)
+# 	end
+#
+# @public Since *Async v1*.
+#
+# pkg:gem/async#lib/async/task.rb:52
+class Async::Task < ::Async::Node
+  # Create a new task.
+  # @parameter reactor [Reactor] the reactor this task will run within.
+  # @parameter parent [Task] the parent task.
+  #
+  # pkg:gem/async#lib/async/task.rb:80
+  def initialize(parent = T.unsafe(nil), finished: T.unsafe(nil), **options, &block); end
+
+  # @returns [Boolean] Whether the internal fiber is alive, i.e. it is actively executing.
+  #
+  # pkg:gem/async#lib/async/task.rb:166
+  def alive?; end
+
+  # Annotate the task with a description.
+  #
+  # This will internally try to annotate the fiber if it is running, otherwise it will annotate the task itself.
+  #
+  # @parameter annotation [String] The description to annotate the task with.
+  #
+  # pkg:gem/async#lib/async/task.rb:123
+  def annotate(annotation, &block); end
+
+  # @returns [Object] The annotation of the task.
+  #
+  # pkg:gem/async#lib/async/task.rb:132
+  def annotation; end
+
+  # Run an asynchronous task as a child of the current task.
+  #
+  # @public Since *Async v1*.
+  # @asynchronous May context switch immediately to the new task.
+  #
+  # @yields {|task| ...} in the context of the new task.
+  # @raises [FinishedError] If the task has already finished.
+  # @returns [Task] The child task.
+  #
+  # pkg:gem/async#lib/async/task.rb:247
+  def async(*arguments, **options, &block); end
+
+  # @returns [Array(Thread::Backtrace::Location) | Nil] The backtrace of the task, if available.
+  #
+  # pkg:gem/async#lib/async/task.rb:114
+  def backtrace(*arguments); end
+
+  # Cancel the task and all of its children.
+  #
+  # If `later` is false, it means that `cancel` has been invoked directly. When `later` is true, it means that `cancel` is invoked by `stop_children` or some other indirect mechanism. In that case, if we encounter the "current" fiber, we can't cancel it right away, as it's currently performing `#cancel`. Cancelling it immediately would interrupt the current cancel traversal, so we need to schedule the cancel to occur later.
+  #
+  # @parameter later [Boolean] Whether to cancel the task later, or immediately.
+  # @parameter cause [Exception] The cause of the cancel operation.
+  #
+  # pkg:gem/async#lib/async/task.rb:329
+  def cancel(later = T.unsafe(nil), cause: T.unsafe(nil)); end
+
+  # @returns [Boolean] Whether cancel has been deferred.
+  #
+  # pkg:gem/async#lib/async/task.rb:429
+  def cancel_deferred?; end
+
+  # @returns [Boolean] Whether the task has been cancelled.
+  #
+  # pkg:gem/async#lib/async/task.rb:188
+  def cancelled?; end
+
+  # Alias for {#completed?}.
+  #
+  # pkg:gem/async#lib/async/task.rb:198
+  def complete?; end
+
+  # @returns [Boolean] Whether the task has completed execution and generated a result.
+  #
+  # pkg:gem/async#lib/async/task.rb:193
+  def completed?; end
+
+  # @returns [Boolean] Whether this task is the currently executing task.
+  #
+  # pkg:gem/async#lib/async/task.rb:453
+  def current?; end
+
+  # Defer the handling of cancel. During the execution of the given block, if a cancel is requested, it will be deferred until the block exits. This is useful for ensuring graceful shutdown of servers and other long-running tasks. You should wrap the response handling code in a defer_cancel block to ensure that the task is cancelled when the response is complete but not before.
+  #
+  # You can nest calls to defer_cancel, but the cancel will only be deferred until the outermost block exits.
+  #
+  # If cancel is invoked a second time, it will be immediately executed.
+  #
+  # @yields {} The block of code to execute.
+  # @public Since *Async v1*.
+  #
+  # pkg:gem/async#lib/async/task.rb:390
+  def defer_cancel; end
+
+  # Backward compatibility alias for {#defer_cancel}.
+  # @deprecated Use {#defer_cancel} instead.
+  #
+  # pkg:gem/async#lib/async/task.rb:424
+  def defer_stop(&block); end
+
+  # @returns [Boolean] Whether the task failed with an exception.
+  #
+  # pkg:gem/async#lib/async/task.rb:183
+  def failed?; end
+
+  # @attribute [Fiber] The fiber which is being used for the execution of this task.
+  #
+  # pkg:gem/async#lib/async/task.rb:163
+  def fiber; end
+
+  # Whether we can remove this node from the reactor graph.
+  # @returns [Boolean]
+  #
+  # pkg:gem/async#lib/async/task.rb:172
+  def finished?; end
+
+  # For compatibility with `Thread#join` and similar interfaces.
+  #
+  # pkg:gem/async#lib/async/task.rb:280
+  def join(*, **, &); end
+
+  # @returns [Scheduler] The scheduler for this task.
+  #
+  # pkg:gem/async#lib/async/task.rb:109
+  def reactor; end
+
+  # Access the result of the task without waiting. May be nil if the task is not completed. Does not raise exceptions.
+  #
+  # pkg:gem/async#lib/async/task.rb:312
+  def result; end
+
+  # Begin the execution of the task.
+  #
+  # @raises [RuntimeError] If the task is already running.
+  #
+  # pkg:gem/async#lib/async/task.rb:219
+  def run(*arguments); end
+
+  # @returns [Boolean] Whether the task is running.
+  #
+  # pkg:gem/async#lib/async/task.rb:178
+  def running?; end
+
+  # @deprecated Prefer {Kernel#sleep} except when compatibility with `stable-v1` is required.
+  #
+  # pkg:gem/async#lib/async/task.rb:146
+  def sleep(duration = T.unsafe(nil)); end
+
+  # @attribute [Symbol] The status of the execution of the task, one of `:initialized`, `:running`, `:complete`, `:cancelled` or `:failed`.
+  #
+  # pkg:gem/async#lib/async/task.rb:203
+  def status; end
+
+  # Backward compatibility alias for {#cancel_deferred?}.
+  # @deprecated Use {#cancel_deferred?} instead.
+  #
+  # pkg:gem/async#lib/async/task.rb:435
+  def stop_deferred?; end
+
+  # @returns [String] A description of the task and it's current status.
+  #
+  # pkg:gem/async#lib/async/task.rb:141
+  def to_s; end
+
+  # Retrieve the current result of the task. Will cause the caller to wait until result is available. If the task resulted in an unhandled error (derived from `StandardError`), this will be raised. If the task was cancelled, this will return `nil`.
+  #
+  # Conceptually speaking, waiting on a task should return a result, and if it throws an exception, this is certainly an exceptional case that should represent a failure in your program, not an expected outcome. In other words, you should not design your programs to expect exceptions from `#wait` as a normal flow control, and prefer to catch known exceptions within the task itself and return a result that captures the intention of the failure, e.g. a `TimeoutError` might simply return `nil` or `false` to indicate that the operation did not generate a valid result (as a timeout was an expected outcome of the internal operation in this case).
+  #
+  # @parameter timeout [Numeric] The maximum number of seconds to wait for the result before raising a `TimeoutError`, if specified.
+  # @raises [RuntimeError] If the task's fiber is the current fiber.
+  # @returns [Object] The final expression/result of the task's block.
+  # @asynchronous This method is thread-safe.
+  #
+  # pkg:gem/async#lib/async/task.rb:272
+  def wait(*, **, &); end
+
+  # Wait on all non-transient children to complete, recursively, then wait on the task itself, if it is not the current task.
+  #
+  # If any child task fails with an exception, that exception will be raised immediately, and remaining children may not be waited on.
+  #
+  # @example Waiting on all children.
+  # 	Async do |task|
+  # 		child = task.async do
+  # 			sleep(0.01)
+  # 		end
+  # 		task.wait_all # Will wait on the child task.
+  # 	end
+  #
+  # @raises [StandardError] If any child task failed with an exception, that exception will be raised.
+  # @returns [Object | Nil] The final expression/result of the task's block, or nil if called from within the task.
+  # @asynchronous This method is thread-safe.
+  #
+  # pkg:gem/async#lib/async/task.rb:297
+  def wait_all; end
+
+  # Execute the given block of code, raising the specified exception if it exceeds the given duration during a non-blocking operation.
+  #
+  # pkg:gem/async#lib/async/task.rb:153
+  def with_timeout(duration, exception = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  # Yield back to the reactor and allow other fibers to execute.
+  #
+  # pkg:gem/async#lib/async/task.rb:158
+  def yield; end
+
+  private
+
+  # pkg:gem/async#lib/async/task.rb:515
+  def cancel!(cause = T.unsafe(nil)); end
+
+  # pkg:gem/async#lib/async/task.rb:488
+  def cancelled!(cause = T.unsafe(nil)); end
+
+  # State transition into the completed state.
+  #
+  # pkg:gem/async#lib/async/task.rb:477
+  def completed!(result); end
+
+  # State transition into the failed state.
+  #
+  # pkg:gem/async#lib/async/task.rb:483
+  def failed!(exception = T.unsafe(nil)); end
+
+  # Finish the current task, moving any children to the parent.
+  #
+  # pkg:gem/async#lib/async/task.rb:464
+  def finish!; end
+
+  # pkg:gem/async#lib/async/task.rb:525
+  def schedule(&block); end
+
+  # pkg:gem/async#lib/async/task.rb:521
+  def stop!; end
+
+  # pkg:gem/async#lib/async/task.rb:511
+  def stopped!; end
+
+  # pkg:gem/async#lib/async/task.rb:459
+  def warn(*, **, &); end
+
+  class << self
+    # Lookup the {Task} for the current fiber. Raise `RuntimeError` if none is available.
+    # @returns [Task]
+    # @raises[RuntimeError] If task was not {set!} for the current fiber.
+    #
+    # pkg:gem/async#lib/async/task.rb:442
+    def current; end
+
+    # Check if there is a task defined for the current fiber.
+    # @returns [Interface(:async) | Nil]
+    #
+    # pkg:gem/async#lib/async/task.rb:448
+    def current?; end
+
+    # Run the given block of code in a task, asynchronously, in the given scheduler.
+    #
+    # pkg:gem/async#lib/async/task.rb:71
+    def run(scheduler, *arguments, **options, &block); end
+
+    # @deprecated With no replacement.
+    #
+    # pkg:gem/async#lib/async/task.rb:64
+    def yield; end
+  end
+end
+
+# Raised when a child task is created within a task that has finished execution.
+#
+# pkg:gem/async#lib/async/task.rb:54
+class Async::Task::FinishedError < ::RuntimeError
+  # Create a new finished error.
+  #
+  # @parameter message [String] The error message.
+  #
+  # pkg:gem/async#lib/async/task.rb:58
+  def initialize(message = T.unsafe(nil)); end
+end
+
+# Represents a flexible timeout that can be rescheduled or extended.
+# @public Since *Async v2.24*.
+#
+# pkg:gem/async#lib/async/timeout.rb:9
+class Async::Timeout
+  # Initialize a new timeout.
+  #
+  # pkg:gem/async#lib/async/timeout.rb:11
+  def initialize(timers, handle); end
+
+  # Adjust the timeout by the specified duration.
+  #
+  # The duration is relative to the timeout time, e.g. adjusting the timeout by 5 increases the current duration by 5 seconds.
+  #
+  # @parameter duration [Numeric] The duration to adjust the timeout by, in seconds.
+  # @returns [Numeric] The new time at which the timeout will occur.
+  #
+  # pkg:gem/async#lib/async/timeout.rb:36
+  def adjust(duration); end
+
+  # Cancel the timeout, preventing it from executing.
+  #
+  # pkg:gem/async#lib/async/timeout.rb:59
+  def cancel!; end
+
+  # @returns [Boolean] Whether the timeout has been cancelled.
+  #
+  # pkg:gem/async#lib/async/timeout.rb:64
+  def cancelled?; end
+
+  # @returns [Numeric] The time remaining until the timeout occurs, in seconds.
+  #
+  # pkg:gem/async#lib/async/timeout.rb:17
+  def duration; end
+
+  # Update the duration of the timeout.
+  #
+  # The duration is relative to the current time, e.g. setting the duration to 5 means the timeout will occur in 5 seconds from now.
+  #
+  # @parameter value [Numeric] The new duration to assign to the timeout, in seconds.
+  #
+  # pkg:gem/async#lib/async/timeout.rb:26
+  def duration=(value); end
+
+  # @returns [Numeric] The current time in the scheduler, relative to the time of this timeout, in seconds.
+  #
+  # pkg:gem/async#lib/async/timeout.rb:54
+  def now; end
+
+  # @returns [Numeric] The time at which the timeout will occur, in seconds since {now}.
+  #
+  # pkg:gem/async#lib/async/timeout.rb:41
+  def time; end
+
+  # Assign a new time to the timeout, rescheduling it if necessary.
+  #
+  # @parameter value [Numeric] The new time to assign to the timeout.
+  # @returns [Numeric] The new time at which the timeout will occur.
+  #
+  # pkg:gem/async#lib/async/timeout.rb:49
+  def time=(value); end
+
+  private
+
+  # Reschedule the timeout to occur at the specified time.
+  #
+  # @parameter time [Numeric] The new time to schedule the timeout for.
+  # @returns [Numeric] The new time at which the timeout will occur.
+  #
+  # pkg:gem/async#lib/async/timeout.rb:76
+  def reschedule(time); end
+end
+
+# Raised when attempting to reschedule a cancelled timeout.
+#
+# pkg:gem/async#lib/async/timeout.rb:69
+class Async::Timeout::CancelledError < ::RuntimeError; end
+
+# Raised if a timeout occurs on a specific Fiber. Handled gracefully by `Task`.
+# @public Since *Async v1*.
+#
+# pkg:gem/async#lib/async/error.rb:9
+class Async::TimeoutError < ::StandardError
+  # Create a new timeout error.
+  #
+  # @parameter message [String] The error message.
+  #
+  # pkg:gem/async#lib/async/error.rb:13
+  def initialize(message = T.unsafe(nil)); end
+end
+
+# pkg:gem/async#lib/async/version.rb:8
+Async::VERSION = T.let(T.unsafe(nil), String)
+
+# A synchronization primitive that allows one task to wait for another task to resolve a value.
+#
+# @deprecated Use {Async::Promise} instead.
+#
+# pkg:gem/async#lib/async/variable.rb:13
+class Async::Variable
+  # Create a new variable.
+  #
+  # @parameter condition [Condition] The condition to use for synchronization.
+  #
+  # pkg:gem/async#lib/async/variable.rb:17
+  def initialize(condition = T.unsafe(nil)); end
+
+  # Resolve the value.
+  #
+  # Signals all waiting tasks.
+  #
+  # @parameter value [Object] The value to resolve.
+  #
+  # pkg:gem/async#lib/async/variable.rb:29
+  def resolve(value = T.unsafe(nil)); end
+
+  # Whether the value has been resolved.
+  #
+  # @returns [Boolean] Whether the value has been resolved.
+  #
+  # pkg:gem/async#lib/async/variable.rb:47
+  def resolved?; end
+
+  # Alias for {#wait}.
+  #
+  # pkg:gem/async#lib/async/variable.rb:60
+  def value; end
+
+  # Alias for {#resolve}.
+  #
+  # pkg:gem/async#lib/async/variable.rb:40
+  def value=(value); end
+
+  # Wait for the value to be resolved.
+  #
+  # @returns [Object] The resolved value.
+  #
+  # pkg:gem/async#lib/async/variable.rb:54
+  def wait; end
+end
+
+# Extensions to all Ruby objects.
+#
+# pkg:gem/async#lib/kernel/async.rb:9
+module Kernel
+  # Run the given block of code in a task, asynchronously, creating a reactor if necessary.
+  #
+  # The preferred method to invoke asynchronous behavior at the top level.
+  #
+  # - When invoked within an existing reactor task, it will run the given block
+  # asynchronously. Will return the task once it has been scheduled.
+  # - When invoked at the top level, will create and run a reactor, and invoke
+  # the block as an asynchronous task. Will block until the reactor finishes
+  # running.
+  #
+  # @yields {|task| ...} The block that will execute asynchronously.
+  # 	@parameter task [Async::Task] The task that is executing the given block.
+  #
+  # @public Since *Async v1*.
+  # @asynchronous May block until given block completes executing.
+  #
+  # pkg:gem/async#lib/kernel/async.rb:25
+  def Async(*, **, &); end
+
+  # Create a barrier, yield it to the block, and then wait for all tasks to complete.
+  #
+  # If no scheduler is running, one will be created automatically for the duration of the block.
+  #
+  # By default, the barrier uses an `Async::Idler` to manage load, but this can be overridden by providing a different parent or `nil` to disable load management.
+  #
+  # @parameter parent [Task | Semaphore | Nil] The parent for holding any children tasks.
+  # @parameter **options [Hash] Additional options passed to {Kernel::Sync}.
+  # @public Since *Async v2.34*.
+  #
+  # pkg:gem/async#lib/kernel/barrier.rb:20
+  def Barrier(parent: T.unsafe(nil), **options); end
+
+  # Run the given block of code synchronously, but within a reactor if not already in one.
+  #
+  # @yields {|task| ...} The block that will execute asynchronously.
+  # 	@parameter task [Async::Task] The task that is executing the given block.
+  #
+  # @public Since *Async v1*.
+  # @asynchronous Will block until given block completes executing.
+  #
+  # pkg:gem/async#lib/kernel/sync.rb:20
+  def Sync(annotation: T.unsafe(nil), &block); end
+end
+
+module Process
+  extend ::Async::ForkHandler
+end