# This file is autogenerated. Do not edit it by hand. Regenerate it with:
#   srb rbi gems

# typed: true
#
# If you would like to make changes to this file, great! Please create the gem's shim here:
#
#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/concurrent-ruby/all/concurrent-ruby.rbi
#
# concurrent-ruby-1.1.8

module Concurrent
  extend Concurrent::Utility::EngineDetector
  extend Concurrent::Utility::NativeExtensionLoader
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 = nil, comparison, major, minor, patch); end
end
module Concurrent::Synchronization
end
class Concurrent::Synchronization::AbstractObject
  def full_memory_barrier; end
  def initialize; end
  def self.attr_volatile(*names); end
end
module Concurrent::Utility::NativeExtensionLoader
  def allow_c_extensions?; end
  def c_extensions_loaded?; end
  def java_extensions_loaded?; end
  def load_error_path(error); end
  def load_native_extensions; end
  def set_c_extensions_loaded; end
  def set_java_extensions_loaded; end
  def try_load_c_extension(path); end
end
module Concurrent::Synchronization::MriAttrVolatile
  def full_memory_barrier; end
  def self.included(base); end
end
module Concurrent::Synchronization::MriAttrVolatile::ClassMethods
  def attr_volatile(*names); end
end
class Concurrent::Synchronization::MriObject < Concurrent::Synchronization::AbstractObject
  def initialize; end
  extend Concurrent::Synchronization::MriAttrVolatile::ClassMethods
  include Concurrent::Synchronization::MriAttrVolatile
end
module Concurrent::Synchronization::RbxAttrVolatile
  def full_memory_barrier; end
  def self.included(base); end
end
module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
  def attr_volatile(*names); end
end
class Concurrent::Synchronization::RbxObject < Concurrent::Synchronization::AbstractObject
  def initialize; end
  extend Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
  include Concurrent::Synchronization::RbxAttrVolatile
end
module Concurrent::Synchronization::TruffleRubyAttrVolatile
  def full_memory_barrier; end
  def self.included(base); end
end
module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
  def attr_volatile(*names); end
end
class Concurrent::Synchronization::TruffleRubyObject < Concurrent::Synchronization::AbstractObject
  def initialize; end
  extend Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
  include Concurrent::Synchronization::TruffleRubyAttrVolatile
end
class Concurrent::Synchronization::Object < Concurrent::Synchronization::MriObject
  def __initialize_atomic_fields__; end
  def initialize; end
  def self.atomic_attribute?(name); end
  def self.atomic_attributes(inherited = nil); end
  def self.attr_atomic(*names); end
  def self.define_initialize_atomic_fields; end
  def self.ensure_safe_initialization_when_final_fields_are_present; end
  def self.safe_initialization!; end
  def self.safe_initialization?; end
end
class Concurrent::Synchronization::AbstractLockableObject < Concurrent::Synchronization::Object
  def ns_broadcast; end
  def ns_signal; end
  def ns_wait(timeout = nil); end
  def ns_wait_until(timeout = nil, &condition); end
  def synchronize; end
end
module Concurrent::Synchronization::ConditionSignalling
  def ns_broadcast; end
  def ns_signal; end
end
class Concurrent::Synchronization::MutexLockableObject < Concurrent::Synchronization::AbstractLockableObject
  def initialize(*defaults); end
  def ns_wait(timeout = nil); end
  def self.new(*args, &block); end
  def synchronize; end
  include Concurrent::Synchronization::ConditionSignalling
end
class Concurrent::Synchronization::MonitorLockableObject < Concurrent::Synchronization::AbstractLockableObject
  def initialize(*defaults); end
  def ns_wait(timeout = nil); end
  def self.new(*args, &block); end
  def synchronize; end
  include Concurrent::Synchronization::ConditionSignalling
end
class Concurrent::Synchronization::RbxLockableObject < Concurrent::Synchronization::AbstractLockableObject
  def initialize(*defaults); end
  def ns_broadcast; end
  def ns_signal; end
  def ns_wait(timeout = nil); end
  def self.new(*args, &block); end
  def synchronize(&block); end
end
class Concurrent::Synchronization::LockableObject < Concurrent::Synchronization::MutexLockableObject
  def new_condition; end
end
class Concurrent::Synchronization::Condition < Concurrent::Synchronization::LockableObject
  def broadcast; end
  def initialize(lock); end
  def ns_broadcast; end
  def ns_signal; end
  def ns_wait(timeout = nil); end
  def ns_wait_until(timeout = nil, &condition); end
  def self.new(*args, &block); end
  def self.private_new(*args, &block); end
  def signal; end
  def wait(timeout = nil); end
  def wait_until(timeout = nil, &condition); end
end
class Concurrent::Synchronization::Lock < Concurrent::Synchronization::LockableObject
  def broadcast; end
  def ns_broadcast; end
  def ns_signal; end
  def ns_wait(timeout = nil); end
  def ns_wait_until(timeout = nil, &condition); end
  def signal; end
  def synchronize; end
  def wait(timeout = nil); end
  def wait_until(timeout = nil, &condition); end
end
module Concurrent::Collection
end
class Concurrent::Collection::NonConcurrentMapBackend
  def [](key); end
  def []=(key, value); end
  def _get(key); end
  def _set(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 dupped_backend; end
  def each_pair; end
  def get_and_set(key, value); end
  def get_or_default(key, default_value); end
  def initialize(options = nil); end
  def initialize_copy(other); end
  def key?(key); end
  def merge_pair(key, value); end
  def pair?(key, expected_value); end
  def replace_if_exists(key, new_value); end
  def replace_pair(key, old_value, new_value); end
  def size; end
  def store_computed_value(key, new_value); end
end
class Concurrent::Collection::MriMapBackend < Concurrent::Collection::NonConcurrentMapBackend
  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 initialize(options = nil); 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::Map < Concurrent::Collection::MriMapBackend
  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 = nil); end
  def fetch_or_store(key, default_value = nil); end
  def get(key); end
  def initialize(options = nil, &block); end
  def initialize_copy(other); end
  def inspect; end
  def key(value); end
  def keys; end
  def marshal_dump; end
  def marshal_load(hash); end
  def populate_from(hash); end
  def put(key, value); end
  def put_if_absent(key, value); end
  def raise_fetch_no_key; end
  def validate_options_hash!(options); end
  def value?(value); end
  def values; end
end
module Concurrent::ThreadSafe
end
module Concurrent::ThreadSafe::Util
end
class Concurrent::Hash < Hash
end