# DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `concurrent-ruby` gem. # Please instead update this file by running `bin/tapioca sync`. # typed: true module Concurrent extend(::Concurrent::Utility::EngineDetector) extend(::Concurrent::Utility::NativeExtensionLoader) extend(::Logger::Severity) extend(::Concurrent::Concern::Logging) extend(::Concurrent::Concern::Deprecation) private def abort_transaction; end def atomically; end def call_dataflow(method, executor, *inputs, &block); end def dataflow(*inputs, &block); end def dataflow!(*inputs, &block); end def dataflow_with(executor, *inputs, &block); end def dataflow_with!(executor, *inputs, &block); end def leave_transaction; end def monotonic_time; end class << self def abort_transaction; end def atomically; end def call_dataflow(method, executor, *inputs, &block); end def create_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end def create_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end def dataflow(*inputs, &block); end def dataflow!(*inputs, &block); end def dataflow_with(executor, *inputs, &block); end def dataflow_with!(executor, *inputs, &block); end def disable_at_exit_handlers!; end def executor(executor_identifier); end def global_fast_executor; end def global_immediate_executor; end def global_io_executor; end def global_logger; end def global_logger=(value); end def global_timer_set; end def leave_transaction; end def monotonic_time; end def new_fast_executor(opts = T.unsafe(nil)); end def new_io_executor(opts = T.unsafe(nil)); end def physical_processor_count; end def processor_count; end def processor_counter; end def use_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end def use_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end end end class Concurrent::AbstractExchanger < ::Concurrent::Synchronization::Object def initialize; end def exchange(value, timeout = T.unsafe(nil)); end def exchange!(value, timeout = T.unsafe(nil)); end def try_exchange(value, timeout = T.unsafe(nil)); end private def do_exchange(value, timeout); end end class Concurrent::AbstractExecutorService < ::Concurrent::Synchronization::LockableObject include(::Logger::Severity) include(::Concurrent::Concern::Logging) include(::Concurrent::ExecutorService) include(::Concurrent::Concern::Deprecation) def initialize(opts = T.unsafe(nil), &block); end def auto_terminate=(value); end def auto_terminate?; end def fallback_policy; end def kill; end def name; end def running?; end def shutdown; end def shutdown?; end def shuttingdown?; end def to_s; end def wait_for_termination(timeout = T.unsafe(nil)); end private def handle_fallback(*args); end def ns_auto_terminate?; end def ns_execute(*args, &task); end def ns_kill_execution; end def ns_shutdown_execution; end end Concurrent::AbstractExecutorService::FALLBACK_POLICIES = T.let(T.unsafe(nil), Array) class Concurrent::AbstractThreadLocalVar def initialize(default = T.unsafe(nil), &default_block); end def bind(value, &block); end def value; end def value=(value); end protected def allocate_storage; end def default; end end class Concurrent::Agent < ::Concurrent::Synchronization::LockableObject include(::Concurrent::Concern::Observable) def initialize(initial, opts = T.unsafe(nil)); end def <<(action); end def await; end def await_for(timeout); end def await_for!(timeout); end def deref; end def error; end def error_mode; end def failed?; end def post(*args, &action); end def reason; end def restart(new_value, opts = T.unsafe(nil)); end def send(*args, &action); end def send!(*args, &action); end def send_off(*args, &action); end def send_off!(*args, &action); end def send_via(executor, *args, &action); end def send_via!(executor, *args, &action); end def stopped?; end def value; end def wait(timeout = T.unsafe(nil)); end private def enqueue_action_job(action, args, executor); end def enqueue_await_job(latch); end def execute_next_job; end def handle_error(error); end def ns_enqueue_job(job, index = T.unsafe(nil)); end def ns_find_last_job_for_thread; end def ns_initialize(initial, opts); end def ns_post_next_job; end def ns_validate(value); end class << self def await(*agents); end def await_for(timeout, *agents); end def await_for!(timeout, *agents); end end end class Concurrent::Agent::Error < ::StandardError def initialize(message = T.unsafe(nil)); end end class Concurrent::Agent::ValidationError < ::Concurrent::Agent::Error def initialize(message = T.unsafe(nil)); end end class Concurrent::Array < ::Array end module Concurrent::Async def async; end def await; end def call; end def cast; end def init_synchronization; end class << self def included(base); end def validate_argc(obj, method, *args); end end end class Concurrent::Atom < ::Concurrent::Synchronization::Object include(::Concurrent::Concern::Observable) def initialize(value, opts = T.unsafe(nil)); end def __initialize_atomic_fields__; end def compare_and_set(old_value, new_value); end def deref; end def reset(new_value); end def swap(*args); end def value; end private def compare_and_set_value(expected, value); end def swap_value(value); end def update_value(&block); end def valid?(new_value); end def value=(value); end class << self def new(*args, &block); end end end class Concurrent::AtomicBoolean < ::Concurrent::MutexAtomicBoolean def inspect; end def to_s; end end module Concurrent::AtomicDirectUpdate def try_update; end def try_update!; end def update; end end class Concurrent::AtomicFixnum < ::Concurrent::MutexAtomicFixnum def inspect; end def to_s; end end class Concurrent::AtomicMarkableReference < ::Concurrent::Synchronization::Object def initialize(value = T.unsafe(nil), mark = T.unsafe(nil)); end def __initialize_atomic_fields__; end def compare_and_set(expected_val, new_val, expected_mark, new_mark); end def compare_and_swap(expected_val, new_val, expected_mark, new_mark); end def get; end def mark; end def marked?; end def set(new_val, new_mark); end def try_update; end def try_update!; end def update; end def value; end private def compare_and_set_reference(expected, value); end def immutable_array(*args); end def reference; end def reference=(value); end def swap_reference(value); end def update_reference(&block); end class << self def new(*args, &block); end end end module Concurrent::AtomicNumericCompareAndSetWrapper def compare_and_set(old_value, new_value); end end class Concurrent::AtomicReference < ::Concurrent::MutexAtomicReference def inspect; end def to_s; end end class Concurrent::CachedThreadPool < ::Concurrent::ThreadPoolExecutor def initialize(opts = T.unsafe(nil)); end private def ns_initialize(opts); end end class Concurrent::CancelledOperationError < ::Concurrent::Error end module Concurrent::Collection end class Concurrent::Collection::CopyOnNotifyObserverSet < ::Concurrent::Synchronization::LockableObject def initialize; end def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end def count_observers; end def delete_observer(observer); end def delete_observers; end def notify_and_delete_observers(*args, &block); end def notify_observers(*args, &block); end protected def ns_initialize; end private def duplicate_and_clear_observers; end def duplicate_observers; end def notify_to(observers, *args); end end class Concurrent::Collection::CopyOnWriteObserverSet < ::Concurrent::Synchronization::LockableObject def initialize; end def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end def count_observers; end def delete_observer(observer); end def delete_observers; end def notify_and_delete_observers(*args, &block); end def notify_observers(*args, &block); end protected def ns_initialize; end private def clear_observers_and_return_old; end def notify_to(observers, *args); end def observers; end def observers=(new_set); end end Concurrent::Collection::MapImplementation = Concurrent::Collection::MriMapBackend class Concurrent::Collection::MriMapBackend < ::Concurrent::Collection::NonConcurrentMapBackend def initialize(options = T.unsafe(nil)); end def []=(key, value); end def clear; end def compute(key); end def compute_if_absent(key); end def compute_if_present(key); end def delete(key); end def delete_pair(key, value); end def get_and_set(key, value); end def merge_pair(key, value); end def replace_if_exists(key, new_value); end def replace_pair(key, old_value, new_value); end end class Concurrent::Collection::NonConcurrentMapBackend def initialize(options = T.unsafe(nil)); end def [](key); end def []=(key, value); end def clear; end def compute(key); end def compute_if_absent(key); end def compute_if_present(key); end def delete(key); end def delete_pair(key, value); end def each_pair; end def get_and_set(key, value); end def get_or_default(key, default_value); end def key?(key); end def merge_pair(key, value); end def replace_if_exists(key, new_value); end def replace_pair(key, old_value, new_value); end def size; end private def _get(key); end def _set(key, value); end def dupped_backend; end def initialize_copy(other); end def pair?(key, expected_value); end def store_computed_value(key, new_value); end end class Concurrent::Collection::NonConcurrentPriorityQueue < ::Concurrent::Collection::RubyNonConcurrentPriorityQueue def <<(item); end def deq; end def enq(item); end def has_priority?(item); end def shift; end def size; end end class Concurrent::Collection::RubyNonConcurrentPriorityQueue def initialize(opts = T.unsafe(nil)); end def <<(item); end def clear; end def delete(item); end def deq; end def empty?; end def enq(item); end def has_priority?(item); end def include?(item); end def length; end def peek; end def pop; end def push(item); end def shift; end def size; end private def ordered?(x, y); end def sink(k); end def swap(x, y); end def swim(k); end class << self def from_list(list, opts = T.unsafe(nil)); end end end module Concurrent::Concern end module Concurrent::Concern::Deprecation include(::Logger::Severity) include(::Concurrent::Concern::Logging) extend(::Logger::Severity) extend(::Concurrent::Concern::Logging) extend(::Concurrent::Concern::Deprecation) def deprecated(message, strip = T.unsafe(nil)); end def deprecated_method(old_name, new_name); end end module Concurrent::Concern::Dereferenceable def deref; end def value; end protected def apply_deref_options(value); end def ns_set_deref_options(opts); end def set_deref_options(opts = T.unsafe(nil)); end def value=(value); end end module Concurrent::Concern::Logging include(::Logger::Severity) def log(level, progname, message = T.unsafe(nil), &block); end end module Concurrent::Concern::Obligation include(::Concurrent::Concern::Dereferenceable) def complete?; end def exception(*args); end def fulfilled?; end def incomplete?; end def no_error!(timeout = T.unsafe(nil)); end def pending?; end def realized?; end def reason; end def rejected?; end def state; end def unscheduled?; end def value(timeout = T.unsafe(nil)); end def value!(timeout = T.unsafe(nil)); end def wait(timeout = T.unsafe(nil)); end def wait!(timeout = T.unsafe(nil)); end protected def compare_and_set_state(next_state, *expected_current); end def event; end def get_arguments_from(opts = T.unsafe(nil)); end def if_state(*expected_states); end def init_obligation; end def ns_check_state?(expected); end def ns_set_state(value); end def set_state(success, value, reason); end def state=(value); end end module Concurrent::Concern::Observable def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end def count_observers; end def delete_observer(observer); end def delete_observers; end def with_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end protected def observers; end def observers=(_arg0); end end class Concurrent::ConcurrentUpdateError < ::ThreadError end Concurrent::ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE = T.let(T.unsafe(nil), Array) class Concurrent::ConfigurationError < ::Concurrent::Error end class Concurrent::CountDownLatch < ::Concurrent::MutexCountDownLatch end class Concurrent::CyclicBarrier < ::Concurrent::Synchronization::LockableObject def initialize(parties, &block); end def broken?; end def number_waiting; end def parties; end def reset; end def wait(timeout = T.unsafe(nil)); end protected def ns_generation_done(generation, status, continue = T.unsafe(nil)); end def ns_initialize(parties, &block); end def ns_next_generation; end end class Concurrent::Delay < ::Concurrent::Synchronization::LockableObject include(::Concurrent::Concern::Dereferenceable) include(::Concurrent::Concern::Obligation) def initialize(opts = T.unsafe(nil), &block); end def reconfigure(&block); end def value(timeout = T.unsafe(nil)); end def value!(timeout = T.unsafe(nil)); end def wait(timeout = T.unsafe(nil)); end protected def ns_initialize(opts, &block); end private def execute_task_once; end end class Concurrent::DependencyCounter def initialize(count, &block); end def update(time, value, reason); end end class Concurrent::Error < ::StandardError end class Concurrent::Event < ::Concurrent::Synchronization::LockableObject def initialize; end def reset; end def set; end def set?; end def try?; end def wait(timeout = T.unsafe(nil)); end protected def ns_initialize; end def ns_set; end end class Concurrent::Exchanger < ::Concurrent::RubyExchanger end module Concurrent::ExecutorService include(::Logger::Severity) include(::Concurrent::Concern::Logging) def <<(task); end def can_overflow?; end def post(*args, &task); end def serialized?; end end class Concurrent::FixedThreadPool < ::Concurrent::ThreadPoolExecutor def initialize(num_threads, opts = T.unsafe(nil)); end end class Concurrent::Future < ::Concurrent::IVar def initialize(opts = T.unsafe(nil), &block); end def cancel; end def cancelled?; end def execute; end def set(value = T.unsafe(nil), &block); end def wait_or_cancel(timeout); end protected def ns_initialize(value, opts); end class << self def execute(opts = T.unsafe(nil), &block); end end end class Concurrent::Hash < ::Hash end class Concurrent::IVar < ::Concurrent::Synchronization::LockableObject include(::Concurrent::Concern::Dereferenceable) include(::Concurrent::Concern::Obligation) include(::Concurrent::Concern::Observable) def initialize(value = T.unsafe(nil), opts = T.unsafe(nil), &block); end def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end def fail(reason = T.unsafe(nil)); end def set(value = T.unsafe(nil)); end def try_set(value = T.unsafe(nil), &block); end protected def check_for_block_or_value!(block_given, value); end def complete(success, value, reason); end def complete_without_notification(success, value, reason); end def notify_observers(value, reason); end def ns_complete_without_notification(success, value, reason); end def ns_initialize(value, opts); end def safe_execute(task, args = T.unsafe(nil)); end end class Concurrent::IllegalOperationError < ::Concurrent::Error end class Concurrent::ImmediateExecutor < ::Concurrent::AbstractExecutorService include(::Concurrent::SerialExecutorService) def initialize; end def <<(task); end def kill; end def post(*args, &task); end def running?; end def shutdown; end def shutdown?; end def shuttingdown?; end def wait_for_termination(timeout = T.unsafe(nil)); end end class Concurrent::ImmutabilityError < ::Concurrent::Error end module Concurrent::ImmutableStruct include(::Concurrent::Synchronization::AbstractStruct) def ==(other); end def [](member); end def each(&block); end def each_pair(&block); end def inspect; end def merge(other, &block); end def select(&block); end def to_a; end def to_h; end def to_s; end def values; end def values_at(*indexes); end private def initialize_copy(original); end class << self def included(base); end def new(*args, &block); end end end class Concurrent::IndirectImmediateExecutor < ::Concurrent::ImmediateExecutor def initialize; end def post(*args, &task); end end class Concurrent::InitializationError < ::Concurrent::Error end class Concurrent::LifecycleError < ::Concurrent::Error end class Concurrent::LockFreeStack < ::Concurrent::Synchronization::Object include(::Enumerable) def initialize(head = T.unsafe(nil)); end def __initialize_atomic_fields__; end def clear; end def clear_each(&block); end def clear_if(head); end def compare_and_clear(head); end def compare_and_pop(head); end def compare_and_push(head, value); end def each(head = T.unsafe(nil)); end def empty?(head = T.unsafe(nil)); end def inspect; end def peek; end def pop; end def push(value); end def replace_if(head, new_head); end def to_s; end private def compare_and_set_head(expected, value); end def head; end def head=(value); end def swap_head(value); end def update_head(&block); end class << self def new(*args, &block); end def of1(value); end def of2(value1, value2); end end end Concurrent::LockFreeStack::EMPTY = T.let(T.unsafe(nil), Concurrent::LockFreeStack::Node) class Concurrent::LockFreeStack::Node def initialize(value, next_node); end def next_node; end def value; end def value=(_arg0); end class << self def [](*_arg0); end end end class Concurrent::MVar < ::Concurrent::Synchronization::Object include(::Concurrent::Concern::Dereferenceable) def initialize(value = T.unsafe(nil), opts = T.unsafe(nil)); end def borrow(timeout = T.unsafe(nil)); end def empty?; end def full?; end def modify(timeout = T.unsafe(nil)); end def modify!; end def put(value, timeout = T.unsafe(nil)); end def set!(value); end def take(timeout = T.unsafe(nil)); end def try_put!(value); end def try_take!; end protected def synchronize(&block); end private def unlocked_empty?; end def unlocked_full?; end def wait_for_empty(timeout); end def wait_for_full(timeout); end def wait_while(condition, timeout); end class << self def new(*args, &block); end end end Concurrent::MVar::EMPTY = T.let(T.unsafe(nil), Object) Concurrent::MVar::TIMEOUT = T.let(T.unsafe(nil), Object) class Concurrent::Map < ::Concurrent::Collection::MriMapBackend def initialize(options = T.unsafe(nil), &block); end def [](key); end def each; end def each_key; end def each_pair; end def each_value; end def empty?; end def fetch(key, default_value = T.unsafe(nil)); end def fetch_or_store(key, default_value = T.unsafe(nil)); end def get(key); end def inspect; end def key(value); end def keys; end def marshal_dump; end def marshal_load(hash); end def put(key, value); end def put_if_absent(key, value); end def value?(value); end def values; end private def initialize_copy(other); end def populate_from(hash); end def raise_fetch_no_key; end def validate_options_hash!(options); end end class Concurrent::MaxRestartFrequencyError < ::Concurrent::Error end class Concurrent::Maybe < ::Concurrent::Synchronization::Object include(::Comparable) def initialize(just, nothing); end def <=>(other); end def fulfilled?; end def just; end def just?; end def nothing; end def nothing?; end def or(other); end def reason; end def rejected?; end def value; end class << self def from(*args); end def just(value); end def nothing(error = T.unsafe(nil)); end private def new(*args, &block); end end end Concurrent::Maybe::NONE = T.let(T.unsafe(nil), Object) class Concurrent::MultipleAssignmentError < ::Concurrent::Error def initialize(message = T.unsafe(nil), inspection_data = T.unsafe(nil)); end def inspect; end def inspection_data; end end class Concurrent::MultipleErrors < ::Concurrent::Error def initialize(errors, message = T.unsafe(nil)); end def errors; end end module Concurrent::MutableStruct include(::Concurrent::Synchronization::AbstractStruct) def ==(other); end def [](member); end def []=(member, value); end def each(&block); end def each_pair(&block); end def inspect; end def merge(other, &block); end def select(&block); end def to_a; end def to_h; end def to_s; end def values; end def values_at(*indexes); end private def initialize_copy(original); end class << self def new(*args, &block); end end end class Concurrent::MutexAtomicBoolean < ::Concurrent::Synchronization::LockableObject def initialize(initial = T.unsafe(nil)); end def false?; end def make_false; end def make_true; end def true?; end def value; end def value=(value); end protected def ns_initialize(initial); end private def ns_make_value(value); end end class Concurrent::MutexAtomicFixnum < ::Concurrent::Synchronization::LockableObject def initialize(initial = T.unsafe(nil)); end def compare_and_set(expect, update); end def decrement(delta = T.unsafe(nil)); end def down(delta = T.unsafe(nil)); end def increment(delta = T.unsafe(nil)); end def up(delta = T.unsafe(nil)); end def update; end def value; end def value=(value); end protected def ns_initialize(initial); end private def ns_set(value); end end class Concurrent::MutexAtomicReference < ::Concurrent::Synchronization::LockableObject include(::Concurrent::AtomicDirectUpdate) include(::Concurrent::AtomicNumericCompareAndSetWrapper) def initialize(value = T.unsafe(nil)); end def _compare_and_set(old_value, new_value); end def compare_and_swap(old_value, new_value); end def get; end def get_and_set(new_value); end def set(new_value); end def swap(new_value); end def value; end def value=(new_value); end protected def ns_initialize(value); end end class Concurrent::MutexCountDownLatch < ::Concurrent::Synchronization::LockableObject def initialize(count = T.unsafe(nil)); end def count; end def count_down; end def wait(timeout = T.unsafe(nil)); end protected def ns_initialize(count); end end class Concurrent::MutexSemaphore < ::Concurrent::Synchronization::LockableObject def initialize(count); end def acquire(permits = T.unsafe(nil)); end def available_permits; end def drain_permits; end def reduce_permits(reduction); end def release(permits = T.unsafe(nil)); end def try_acquire(permits = T.unsafe(nil), timeout = T.unsafe(nil)); end protected def ns_initialize(count); end private def try_acquire_now(permits); end def try_acquire_timed(permits, timeout); end end Concurrent::NULL = T.let(T.unsafe(nil), Object) Concurrent::NULL_LOGGER = T.let(T.unsafe(nil), Proc) module Concurrent::Options class << self def executor(executor_identifier); end def executor_from_options(opts = T.unsafe(nil)); end end end class Concurrent::Promise < ::Concurrent::IVar def initialize(opts = T.unsafe(nil), &block); end def catch(&block); end def execute; end def fail(reason = T.unsafe(nil)); end def flat_map(&block); end def on_error(&block); end def on_success(&block); end def rescue(&block); end def set(value = T.unsafe(nil), &block); end def then(*args, &block); end def zip(*others); end protected def complete(success, value, reason); end def notify_child(child); end def ns_initialize(value, opts); end def on_fulfill(result); end def on_reject(reason); end def realize(task); end def root?; end def set_pending; end def set_state!(success, value, reason); end def synchronized_set_state!(success, value, reason); end class << self def aggregate(method, *promises); end def all?(*promises); end def any?(*promises); end def execute(opts = T.unsafe(nil), &block); end def fulfill(value, opts = T.unsafe(nil)); end def reject(reason, opts = T.unsafe(nil)); end def zip(*promises); end end end class Concurrent::PromiseExecutionError < ::StandardError end module Concurrent::Promises extend(::Concurrent::Promises::FactoryMethods::Configuration) extend(::Concurrent::Promises::FactoryMethods) end class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization::Object def initialize(promise, default_executor); end def __initialize_atomic_fields__; end def add_callback_clear_delayed_node(node); end def add_callback_notify_blocked(promise, index); end def blocks; end def callbacks; end def chain(*args, &task); end def chain_on(executor, *args, &task); end def chain_resolvable(resolvable); end def default_executor; end def inspect; end def internal_state; end def on_resolution(*args, &callback); end def on_resolution!(*args, &callback); end def on_resolution_using(executor, *args, &callback); end def pending?; end def promise; end def resolve_with(state, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end def resolved?; end def state; end def tangle(resolvable); end def to_s; end def touch; end def touched?; end def wait(timeout = T.unsafe(nil)); end def waiting_threads; end def with_default_executor(executor); end def with_hidden_resolvable; end private def add_callback(method, *args); end def async_callback_on_resolution(state, executor, args, callback); end def call_callback(method, state, args); end def call_callbacks(state); end def callback_clear_delayed_node(state, node); end def callback_notify_blocked(state, promise, index); end def compare_and_set_internal_state(expected, value); end def internal_state=(value); end def swap_internal_state(value); end def update_internal_state(&block); end def wait_until_resolved(timeout); end def with_async(executor, *args, &block); end class << self def new(*args, &block); end end end class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture def &(other); end def any(event_or_future); end def delay; end def schedule(intended_time); end def then(*args, &task); end def to_event; end def to_future; end def with_default_executor(executor); end def zip(other); end def |(event_or_future); end private def callback_on_resolution(state, args, callback); end def rejected_resolution(raise_on_reassign, state); end end module Concurrent::Promises::FactoryMethods include(::Concurrent::Promises::FactoryMethods::Configuration) extend(::Concurrent::ReInclude) extend(::Concurrent::Promises::FactoryMethods::Configuration) extend(::Concurrent::Promises::FactoryMethods) def any(*futures_and_or_events); end def any_event(*futures_and_or_events); end def any_event_on(default_executor, *futures_and_or_events); end def any_fulfilled_future(*futures_and_or_events); end def any_fulfilled_future_on(default_executor, *futures_and_or_events); end def any_resolved_future(*futures_and_or_events); end def any_resolved_future_on(default_executor, *futures_and_or_events); end def delay(*args, &task); end def delay_on(default_executor, *args, &task); end def fulfilled_future(value, default_executor = T.unsafe(nil)); end def future(*args, &task); end def future_on(default_executor, *args, &task); end def make_future(argument = T.unsafe(nil), default_executor = T.unsafe(nil)); end def rejected_future(reason, default_executor = T.unsafe(nil)); end def resolvable_event; end def resolvable_event_on(default_executor = T.unsafe(nil)); end def resolvable_future; end def resolvable_future_on(default_executor = T.unsafe(nil)); end def resolved_event(default_executor = T.unsafe(nil)); end def resolved_future(fulfilled, value, reason, default_executor = T.unsafe(nil)); end def schedule(intended_time, *args, &task); end def schedule_on(default_executor, intended_time, *args, &task); end def zip(*futures_and_or_events); end def zip_events(*futures_and_or_events); end def zip_events_on(default_executor, *futures_and_or_events); end def zip_futures(*futures_and_or_events); end def zip_futures_on(default_executor, *futures_and_or_events); end end module Concurrent::Promises::FactoryMethods::Configuration def default_executor; end end class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture def &(other); end def any(event_or_future); end def apply(args, block); end def delay; end def exception(*args); end def flat(level = T.unsafe(nil)); end def flat_event; end def flat_future(level = T.unsafe(nil)); end def fulfilled?; end def inspect; end def on_fulfillment(*args, &callback); end def on_fulfillment!(*args, &callback); end def on_fulfillment_using(executor, *args, &callback); end def on_rejection(*args, &callback); end def on_rejection!(*args, &callback); end def on_rejection_using(executor, *args, &callback); end def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end def rejected?; end def rescue(*args, &task); end def rescue_on(executor, *args, &task); end def result(timeout = T.unsafe(nil)); end def run(run_test = T.unsafe(nil)); end def schedule(intended_time); end def then(*args, &task); end def then_on(executor, *args, &task); end def to_event; end def to_future; end def to_s; end def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end def wait!(timeout = T.unsafe(nil)); end def with_default_executor(executor); end def zip(other); end def |(event_or_future); end private def async_callback_on_fulfillment(state, executor, args, callback); end def async_callback_on_rejection(state, executor, args, callback); end def callback_on_fulfillment(state, args, callback); end def callback_on_rejection(state, args, callback); end def callback_on_resolution(state, args, callback); end def rejected_resolution(raise_on_reassign, state); end def run_test(v); end def wait_until_resolved!(timeout = T.unsafe(nil)); end end module Concurrent::Promises::Resolvable end class Concurrent::Promises::ResolvableEvent < ::Concurrent::Promises::Event include(::Concurrent::Promises::Resolvable) def resolve(raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end def with_hidden_resolvable; end end class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future include(::Concurrent::Promises::Resolvable) def evaluate_to(*args, &block); end def evaluate_to!(*args, &block); end def fulfill(value, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end def reject(reason, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end def resolve(fulfilled = T.unsafe(nil), value = T.unsafe(nil), reason = T.unsafe(nil), raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end def result(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end def wait!(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end def with_hidden_resolvable; end end module Concurrent::ReInclude def extended(base); end def include(*modules); end def included(base); end end class Concurrent::ReadWriteLock < ::Concurrent::Synchronization::Object def initialize; end def acquire_read_lock; end def acquire_write_lock; end def has_waiters?; end def release_read_lock; end def release_write_lock; end def with_read_lock; end def with_write_lock; end def write_locked?; end private def max_readers?(c = T.unsafe(nil)); end def max_writers?(c = T.unsafe(nil)); end def running_readers(c = T.unsafe(nil)); end def running_readers?(c = T.unsafe(nil)); end def running_writer?(c = T.unsafe(nil)); end def waiting_writer?(c = T.unsafe(nil)); end def waiting_writers(c = T.unsafe(nil)); end class << self def new(*args, &block); end end end Concurrent::ReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer) Concurrent::ReadWriteLock::MAX_WRITERS = T.let(T.unsafe(nil), Integer) Concurrent::ReadWriteLock::RUNNING_WRITER = T.let(T.unsafe(nil), Integer) Concurrent::ReadWriteLock::WAITING_WRITER = T.let(T.unsafe(nil), Integer) class Concurrent::ReentrantReadWriteLock < ::Concurrent::Synchronization::Object def initialize; end def acquire_read_lock; end def acquire_write_lock; end def release_read_lock; end def release_write_lock; end def try_read_lock; end def try_write_lock; end def with_read_lock; end def with_write_lock; end private def max_readers?(c = T.unsafe(nil)); end def max_writers?(c = T.unsafe(nil)); end def running_readers(c = T.unsafe(nil)); end def running_readers?(c = T.unsafe(nil)); end def running_writer?(c = T.unsafe(nil)); end def waiting_or_running_writer?(c = T.unsafe(nil)); end def waiting_writers(c = T.unsafe(nil)); end class << self def new(*args, &block); end end end Concurrent::ReentrantReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer) Concurrent::ReentrantReadWriteLock::MAX_WRITERS = T.let(T.unsafe(nil), Integer) Concurrent::ReentrantReadWriteLock::READER_BITS = T.let(T.unsafe(nil), Integer) Concurrent::ReentrantReadWriteLock::READ_LOCK_MASK = T.let(T.unsafe(nil), Integer) Concurrent::ReentrantReadWriteLock::RUNNING_WRITER = T.let(T.unsafe(nil), Integer) Concurrent::ReentrantReadWriteLock::WAITING_WRITER = T.let(T.unsafe(nil), Integer) Concurrent::ReentrantReadWriteLock::WRITER_BITS = T.let(T.unsafe(nil), Integer) Concurrent::ReentrantReadWriteLock::WRITE_LOCK_HELD = T.let(T.unsafe(nil), Integer) Concurrent::ReentrantReadWriteLock::WRITE_LOCK_MASK = T.let(T.unsafe(nil), Integer) class Concurrent::RejectedExecutionError < ::Concurrent::Error end class Concurrent::ResourceLimitError < ::Concurrent::Error end class Concurrent::RubyExchanger < ::Concurrent::AbstractExchanger def initialize; end def __initialize_atomic_fields__; end def compare_and_set_slot(expected, value); end def slot; end def slot=(value); end def swap_slot(value); end def update_slot(&block); end private def do_exchange(value, timeout); end class << self def new(*args, &block); end end end class Concurrent::RubyExecutorService < ::Concurrent::AbstractExecutorService def initialize(*args, &block); end def kill; end def post(*args, &task); end def shutdown; end def wait_for_termination(timeout = T.unsafe(nil)); end private def ns_running?; end def ns_shutdown?; end def ns_shutdown_execution; end def ns_shuttingdown?; end def stop_event; end def stopped_event; end end class Concurrent::RubySingleThreadExecutor < ::Concurrent::RubyThreadPoolExecutor def initialize(opts = T.unsafe(nil)); end end class Concurrent::RubyThreadLocalVar < ::Concurrent::AbstractThreadLocalVar def value; end def value=(value); end protected def allocate_storage; end private def get_default; end def get_threadlocal_array(thread = T.unsafe(nil)); end def next_index; end def set_threadlocal_array(array, thread = T.unsafe(nil)); end def value_for(thread); end class << self def semi_sync(&block); end def thread_finalizer(id); end def thread_local_finalizer(index); end end end class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService def initialize(opts = T.unsafe(nil)); end def can_overflow?; end def completed_task_count; end def idletime; end def largest_length; end def length; end def max_length; end def max_queue; end def min_length; end def queue_length; end def ready_worker(worker); end def remaining_capacity; end def remove_busy_worker(worker); end def scheduled_task_count; end def synchronous; end def worker_died(worker); end def worker_not_old_enough(worker); end def worker_task_completed; end private def ns_add_busy_worker; end def ns_assign_worker(*args, &task); end def ns_enqueue(*args, &task); end def ns_execute(*args, &task); end def ns_initialize(opts); end def ns_kill_execution; end def ns_limited_queue?; end def ns_prune_pool; end def ns_ready_worker(worker, success = T.unsafe(nil)); end def ns_remove_busy_worker(worker); end def ns_reset_if_forked; end def ns_shutdown_execution; end def ns_worker_died(worker); end def ns_worker_not_old_enough(worker); end end Concurrent::RubyThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE = T.let(T.unsafe(nil), Integer) Concurrent::RubyThreadPoolExecutor::DEFAULT_MAX_QUEUE_SIZE = T.let(T.unsafe(nil), Integer) Concurrent::RubyThreadPoolExecutor::DEFAULT_MIN_POOL_SIZE = T.let(T.unsafe(nil), Integer) Concurrent::RubyThreadPoolExecutor::DEFAULT_THREAD_IDLETIMEOUT = T.let(T.unsafe(nil), Integer) class Concurrent::SafeTaskExecutor < ::Concurrent::Synchronization::LockableObject def initialize(task, opts = T.unsafe(nil)); end def execute(*args); end end class Concurrent::ScheduledTask < ::Concurrent::IVar include(::Comparable) def initialize(delay, opts = T.unsafe(nil), &task); end def <=>(other); end def cancel; end def cancelled?; end def execute; end def executor; end def initial_delay; end def process_task; end def processing?; end def reschedule(delay); end def reset; end def schedule_time; end protected def ns_reschedule(delay); end def ns_schedule(delay); end class << self def execute(delay, opts = T.unsafe(nil), &task); end end end class Concurrent::Semaphore < ::Concurrent::MutexSemaphore end module Concurrent::SerialExecutorService include(::Logger::Severity) include(::Concurrent::Concern::Logging) include(::Concurrent::ExecutorService) def serialized?; end end class Concurrent::SerializedExecution < ::Concurrent::Synchronization::LockableObject include(::Logger::Severity) include(::Concurrent::Concern::Logging) def initialize; end def post(executor, *args, &task); end def posts(posts); end private def call_job(job); end def ns_initialize; end def work(job); end end class Concurrent::SerializedExecution::Job < ::Struct def args; end def args=(_); end def block; end def block=(_); end def call; end def executor; end def executor=(_); end class << self def [](*_arg0); end def inspect; end def members; end def new(*_arg0); end end end class Concurrent::SerializedExecutionDelegator < ::SimpleDelegator include(::Logger::Severity) include(::Concurrent::Concern::Logging) include(::Concurrent::ExecutorService) include(::Concurrent::SerialExecutorService) def initialize(executor); end def post(*args, &task); end end class Concurrent::Set < ::Set end module Concurrent::SettableStruct include(::Concurrent::Synchronization::AbstractStruct) def ==(other); end def [](member); end def []=(member, value); end def each(&block); end def each_pair(&block); end def inspect; end def merge(other, &block); end def select(&block); end def to_a; end def to_h; end def to_s; end def values; end def values_at(*indexes); end private def initialize_copy(original); end class << self def new(*args, &block); end end end class Concurrent::SimpleExecutorService < ::Concurrent::RubyExecutorService def <<(task); end def kill; end def post(*args, &task); end def running?; end def shutdown; end def shutdown?; end def shuttingdown?; end def wait_for_termination(timeout = T.unsafe(nil)); end private def ns_initialize(*args); end class << self def <<(task); end def post(*args); end end end class Concurrent::SingleThreadExecutor < ::Concurrent::RubySingleThreadExecutor end module Concurrent::Synchronization end class Concurrent::Synchronization::AbstractLockableObject < ::Concurrent::Synchronization::Object protected def ns_broadcast; end def ns_signal; end def ns_wait(timeout = T.unsafe(nil)); end def ns_wait_until(timeout = T.unsafe(nil), &condition); end def synchronize; end end class Concurrent::Synchronization::AbstractObject def initialize; end def full_memory_barrier; end class << self def attr_volatile(*names); end end end module Concurrent::Synchronization::AbstractStruct def initialize(*values); end def length; end def members; end def size; end protected def ns_each; end def ns_each_pair; end def ns_equality(other); end def ns_get(member); end def ns_initialize_copy; end def ns_inspect; end def ns_merge(other, &block); end def ns_select; end def ns_to_h; end def ns_values; end def ns_values_at(indexes); end def pr_underscore(clazz); end class << self def define_struct_class(parent, base, name, members, &block); end end end class Concurrent::Synchronization::Condition < ::Concurrent::Synchronization::LockableObject def initialize(lock); end def broadcast; end def ns_broadcast; end def ns_signal; end def ns_wait(timeout = T.unsafe(nil)); end def ns_wait_until(timeout = T.unsafe(nil), &condition); end def signal; end def wait(timeout = T.unsafe(nil)); end def wait_until(timeout = T.unsafe(nil), &condition); end class << self def private_new(*args, &block); end end end module Concurrent::Synchronization::ConditionSignalling protected def ns_broadcast; end def ns_signal; end end class Concurrent::Synchronization::Lock < ::Concurrent::Synchronization::LockableObject def broadcast; end def signal; end def wait(timeout = T.unsafe(nil)); end def wait_until(timeout = T.unsafe(nil), &condition); end end class Concurrent::Synchronization::LockableObject < ::Concurrent::Synchronization::MutexLockableObject def new_condition; end end class Concurrent::Synchronization::MonitorLockableObject < ::Concurrent::Synchronization::AbstractLockableObject include(::Concurrent::Synchronization::ConditionSignalling) def initialize(*defaults); end protected def ns_wait(timeout = T.unsafe(nil)); end def synchronize; end class << self def new(*args, &block); end end end module Concurrent::Synchronization::MriAttrVolatile mixes_in_class_methods(::Concurrent::Synchronization::MriAttrVolatile::ClassMethods) def full_memory_barrier; end class << self def included(base); end end end module Concurrent::Synchronization::MriAttrVolatile::ClassMethods def attr_volatile(*names); end end class Concurrent::Synchronization::MriObject < ::Concurrent::Synchronization::AbstractObject include(::Concurrent::Synchronization::MriAttrVolatile) extend(::Concurrent::Synchronization::MriAttrVolatile::ClassMethods) def initialize; end end class Concurrent::Synchronization::MutexLockableObject < ::Concurrent::Synchronization::AbstractLockableObject include(::Concurrent::Synchronization::ConditionSignalling) def initialize(*defaults); end protected def ns_wait(timeout = T.unsafe(nil)); end def synchronize; end class << self def new(*args, &block); end end end class Concurrent::Synchronization::Object < ::Concurrent::Synchronization::MriObject def initialize; end private def __initialize_atomic_fields__; end class << self def atomic_attribute?(name); end def atomic_attributes(inherited = T.unsafe(nil)); end def attr_atomic(*names); end def ensure_safe_initialization_when_final_fields_are_present; end def safe_initialization!; end def safe_initialization?; end private def define_initialize_atomic_fields; end end end module Concurrent::Synchronization::RbxAttrVolatile mixes_in_class_methods(::Concurrent::Synchronization::RbxAttrVolatile::ClassMethods) def full_memory_barrier; end class << self def included(base); end end end module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods def attr_volatile(*names); end end class Concurrent::Synchronization::RbxLockableObject < ::Concurrent::Synchronization::AbstractLockableObject def initialize(*defaults); end protected def ns_broadcast; end def ns_signal; end def ns_wait(timeout = T.unsafe(nil)); end def synchronize(&block); end class << self def new(*args, &block); end end end class Concurrent::Synchronization::RbxObject < ::Concurrent::Synchronization::AbstractObject include(::Concurrent::Synchronization::RbxAttrVolatile) extend(::Concurrent::Synchronization::RbxAttrVolatile::ClassMethods) def initialize; end end module Concurrent::Synchronization::TruffleRubyAttrVolatile mixes_in_class_methods(::Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods) def full_memory_barrier; end class << self def included(base); end end end module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods def attr_volatile(*names); end end class Concurrent::Synchronization::TruffleRubyObject < ::Concurrent::Synchronization::AbstractObject include(::Concurrent::Synchronization::TruffleRubyAttrVolatile) extend(::Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods) def initialize; end end Concurrent::Synchronization::Volatile = Concurrent::Synchronization::MriAttrVolatile class Concurrent::SynchronizedDelegator < ::SimpleDelegator def initialize(obj); end def method_missing(method, *args, &block); end def setup; end def teardown; end end class Concurrent::TVar < ::Concurrent::Synchronization::Object def initialize(value); end def unsafe_increment_version; end def unsafe_lock; end def unsafe_value; end def unsafe_value=(value); end def unsafe_version; end def value; end def value=(value); end class << self def new(*args, &block); end end end class Concurrent::ThreadLocalVar < ::Concurrent::RubyThreadLocalVar end class Concurrent::ThreadPoolExecutor < ::Concurrent::RubyThreadPoolExecutor end module Concurrent::ThreadSafe end module Concurrent::ThreadSafe::Util end Concurrent::ThreadSafe::Util::CPU_COUNT = T.let(T.unsafe(nil), Integer) Concurrent::ThreadSafe::Util::FIXNUM_BIT_SIZE = T.let(T.unsafe(nil), Integer) Concurrent::ThreadSafe::Util::MAX_INT = T.let(T.unsafe(nil), Integer) class Concurrent::TimeoutError < ::Concurrent::Error end class Concurrent::TimerSet < ::Concurrent::RubyExecutorService def initialize(opts = T.unsafe(nil)); end def kill; end def post(delay, *args, &task); end private def ns_initialize(opts); end def ns_post_task(task); end def ns_reset_if_forked; end def ns_shutdown_execution; end def post_task(task); end def process_tasks; end def remove_task(task); end end class Concurrent::TimerTask < ::Concurrent::RubyExecutorService include(::Concurrent::Concern::Dereferenceable) include(::Concurrent::Concern::Observable) def initialize(opts = T.unsafe(nil), &task); end def execute; end def execution_interval; end def execution_interval=(value); end def running?; end def timeout_interval; end def timeout_interval=(value); end private def execute_task(completion); end def ns_initialize(opts, &task); end def ns_kill_execution; end def ns_shutdown_execution; end def schedule_next_task(interval = T.unsafe(nil)); end def timeout_task(completion); end class << self def execute(opts = T.unsafe(nil), &task); end end end Concurrent::TimerTask::EXECUTION_INTERVAL = T.let(T.unsafe(nil), Integer) Concurrent::TimerTask::TIMEOUT_INTERVAL = T.let(T.unsafe(nil), Integer) class Concurrent::Transaction def initialize; end def abort; end def commit; end def read(tvar); end def unlock; end def valid?; end def write(tvar, value); end class << self def current; end def current=(transaction); end end end Concurrent::Transaction::ABORTED = T.let(T.unsafe(nil), Object) class Concurrent::Transaction::AbortError < ::StandardError end class Concurrent::Transaction::LeaveError < ::StandardError end class Concurrent::Transaction::ReadLogEntry < ::Struct def tvar; end def tvar=(_); end def version; end def version=(_); end class << self def [](*_arg0); end def inspect; end def members; end def new(*_arg0); end end end class Concurrent::Tuple include(::Enumerable) def initialize(size); end def cas(i, old_value, new_value); end def compare_and_set(i, old_value, new_value); end def each; end def get(i); end def set(i, value); end def size; end def volatile_get(i); end def volatile_set(i, value); end end module Concurrent::Utility end module Concurrent::Utility::EngineDetector def on_cruby?; end def on_jruby?; end def on_jruby_9000?; end def on_linux?; end def on_osx?; end def on_rbx?; end def on_truffleruby?; end def on_windows?; end def ruby_engine; end def ruby_version(version = T.unsafe(nil), comparison, major, minor, patch); end end module Concurrent::Utility::NativeExtensionLoader def allow_c_extensions?; end def c_extensions_loaded?; end def java_extensions_loaded?; end def load_native_extensions; end private def load_error_path(error); end def set_c_extensions_loaded; end def set_java_extensions_loaded; end def try_load_c_extension(path); end end module Concurrent::Utility::NativeInteger extend(::Concurrent::Utility::NativeInteger) def ensure_integer(value); end def ensure_integer_and_bounds(value); end def ensure_lower_bound(value); end def ensure_positive(value); end def ensure_positive_and_no_zero(value); end def ensure_upper_bound(value); end end Concurrent::Utility::NativeInteger::MAX_VALUE = T.let(T.unsafe(nil), Integer) Concurrent::Utility::NativeInteger::MIN_VALUE = T.let(T.unsafe(nil), Integer) class Concurrent::Utility::ProcessorCounter def initialize; end def physical_processor_count; end def processor_count; end private def compute_physical_processor_count; end def compute_processor_count; end end Concurrent::VERSION = T.let(T.unsafe(nil), String) Concurrent::Promises::InternalStates::PENDING = T.let(T.unsafe(nil), T.untyped) Concurrent::Promises::InternalStates::RESERVED = T.let(T.unsafe(nil), T.untyped) Concurrent::Promises::InternalStates::RESOLVED = T.let(T.unsafe(nil), T.untyped)