dry-monads-sorbet 1.1.2 → 1.1.6.pre2

data/sorbet/rbi/gems/em-websocket.rbi

@@ -0,0 +1,225 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# 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/em-websocket/all/em-websocket.rbi
+#
+# em-websocket-0.5.1
+
+module EventMachine
+end
+module EventMachine::WebSocket
+  def self.close_timeout; end
+  def self.close_timeout=(arg0); end
+  def self.max_frame_size; end
+  def self.max_frame_size=(arg0); end
+  def self.run(options); end
+  def self.start(options, &blk); end
+  def self.stop; end
+end
+module EventMachine::WebSocket::Debugger
+  def debug(*data); end
+end
+class EventMachine::WebSocket::WebSocketError < RuntimeError
+end
+class EventMachine::WebSocket::HandshakeError < EventMachine::WebSocket::WebSocketError
+end
+class EventMachine::WebSocket::WSProtocolError < EventMachine::WebSocket::WebSocketError
+  def code; end
+end
+class EventMachine::WebSocket::InvalidDataError < EventMachine::WebSocket::WSProtocolError
+  def code; end
+end
+class EventMachine::WebSocket::WSMessageTooBigError < EventMachine::WebSocket::WSProtocolError
+  def code; end
+end
+class EventMachine::WebSocket::Connection < EventMachine::Connection
+  def abort; end
+  def acceptable_close_code?(code); end
+  def close(code = nil, body = nil); end
+  def close_timeout; end
+  def close_websocket(code = nil, body = nil); end
+  def close_websocket_private(code, body); end
+  def dispatch(data); end
+  def initialize(options); end
+  def max_frame_size; end
+  def max_frame_size=(arg0); end
+  def onbinary(&blk); end
+  def onclose(&blk); end
+  def onerror(&blk); end
+  def onmessage(&blk); end
+  def onopen(&blk); end
+  def onping(&blk); end
+  def onpong(&blk); end
+  def ping(body = nil); end
+  def pingable?; end
+  def pong(body = nil); end
+  def post_init; end
+  def receive_data(data); end
+  def send(data); end
+  def send_binary(data); end
+  def send_flash_cross_domain_file; end
+  def send_text(data); end
+  def state; end
+  def supports_close_codes?; end
+  def trigger_on_binary(msg); end
+  def trigger_on_close(event = nil); end
+  def trigger_on_error(reason); end
+  def trigger_on_message(msg); end
+  def trigger_on_open(handshake); end
+  def trigger_on_ping(data); end
+  def trigger_on_pong(data); end
+  def unbind; end
+  include EventMachine::WebSocket::Debugger
+end
+class EventMachine::WebSocket::Handshake
+  def headers; end
+  def headers_downcased; end
+  def initialize(secure); end
+  def origin; end
+  def parser; end
+  def path; end
+  def process(headers, remains); end
+  def protocol_version; end
+  def query; end
+  def query_string; end
+  def receive_data(data); end
+  def secure?; end
+  include EventMachine::Deferrable
+end
+module EventMachine::WebSocket::Handshake75
+  def self.handshake(headers, path, secure); end
+end
+module EventMachine::WebSocket::Handshake76
+  def self.handshake(headers, path, secure); end
+  def self.numbers_over_spaces(string); end
+  def self.solve_challenge(first, second, third); end
+  def self.validate_protocol!(protocol); end
+end
+module EventMachine::WebSocket::Handshake04
+  def self.handshake(headers, _, __); end
+end
+module EventMachine::WebSocket::Framing76
+  def initialize_framing; end
+  def process_data; end
+  def send_text_frame(data); end
+end
+module EventMachine::WebSocket::Framing03
+  def data_frame?(type); end
+  def fin; end
+  def initialize_framing; end
+  def opcode_to_type(opcode); end
+  def process_data; end
+  def send_frame(frame_type, application_data); end
+  def send_text_frame(data); end
+  def type_to_opcode(frame_type); end
+end
+module EventMachine::WebSocket::Framing04
+  def fin; end
+  include EventMachine::WebSocket::Framing03
+end
+module EventMachine::WebSocket::Framing05
+  def data_frame?(type); end
+  def initialize_framing; end
+  def opcode_to_type(opcode); end
+  def process_data; end
+  def send_frame(frame_type, application_data); end
+  def send_text_frame(data); end
+  def type_to_opcode(frame_type); end
+end
+module EventMachine::WebSocket::Framing07
+  def data_frame?(type); end
+  def initialize_framing; end
+  def opcode_to_type(opcode); end
+  def process_data; end
+  def send_frame(frame_type, application_data); end
+  def send_text_frame(data); end
+  def type_to_opcode(frame_type); end
+end
+module EventMachine::WebSocket::Close75
+  def close_websocket(code, body); end
+  def supports_close_codes?; end
+end
+module EventMachine::WebSocket::Close03
+  def close_websocket(code, body); end
+  def supports_close_codes?; end
+end
+module EventMachine::WebSocket::Close05
+  def close_websocket(code, body); end
+  def supports_close_codes?; end
+end
+module EventMachine::WebSocket::Close06
+  def close_websocket(code, body); end
+  def supports_close_codes?; end
+end
+class EventMachine::WebSocket::MaskedString < String
+  def getbyte(index); end
+  def getbytes(start_index, count); end
+  def read_mask; end
+  def unset_mask; end
+end
+module EventMachine::WebSocket::MessageProcessor03
+  def message(message_type, extension_data, application_data); end
+  def pingable?; end
+end
+module EventMachine::WebSocket::MessageProcessor06
+  def message(message_type, extension_data, application_data); end
+  def pingable?; end
+end
+class EventMachine::WebSocket::Handler
+  def close_websocket(code, body); end
+  def fail_websocket(e); end
+  def initialize(connection, debug = nil); end
+  def ping; end
+  def pingable?; end
+  def receive_data(data); end
+  def request; end
+  def self.klass_factory(version); end
+  def start_close_timeout; end
+  def state; end
+  def unbind; end
+  include EventMachine::WebSocket::Debugger
+end
+class EventMachine::WebSocket::Handler75 < EventMachine::WebSocket::Handler
+  include EventMachine::WebSocket::Close75
+  include EventMachine::WebSocket::Framing76
+  include EventMachine::WebSocket::Handshake75
+end
+class EventMachine::WebSocket::Handler76 < EventMachine::WebSocket::Handler
+  include EventMachine::WebSocket::Close75
+  include EventMachine::WebSocket::Framing76
+  include EventMachine::WebSocket::Handshake76
+end
+class EventMachine::WebSocket::Handler03 < EventMachine::WebSocket::Handler
+  include EventMachine::WebSocket::Close03
+  include EventMachine::WebSocket::Framing03
+  include EventMachine::WebSocket::MessageProcessor03
+end
+class EventMachine::WebSocket::Handler05 < EventMachine::WebSocket::Handler
+  include EventMachine::WebSocket::Close05
+  include EventMachine::WebSocket::Framing05
+  include EventMachine::WebSocket::MessageProcessor03
+end
+class EventMachine::WebSocket::Handler06 < EventMachine::WebSocket::Handler
+  include EventMachine::WebSocket::Close06
+  include EventMachine::WebSocket::Framing05
+  include EventMachine::WebSocket::MessageProcessor06
+end
+class EventMachine::WebSocket::Handler07 < EventMachine::WebSocket::Handler
+  include EventMachine::WebSocket::Close06
+  include EventMachine::WebSocket::Framing07
+  include EventMachine::WebSocket::MessageProcessor06
+end
+class EventMachine::WebSocket::Handler08 < EventMachine::WebSocket::Handler
+  include EventMachine::WebSocket::Close06
+  include EventMachine::WebSocket::Framing07
+  include EventMachine::WebSocket::MessageProcessor06
+end
+class EventMachine::WebSocket::Handler13 < EventMachine::WebSocket::Handler
+  include EventMachine::WebSocket::Close06
+  include EventMachine::WebSocket::Framing07
+  include EventMachine::WebSocket::MessageProcessor06
+end

data/sorbet/rbi/gems/eventmachine.rbi

@@ -0,0 +1,489 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# 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/eventmachine/all/eventmachine.rbi
+#
+# eventmachine-1.2.7
+
+module EventMachine
+  def add_oneshot_timer(arg0); end
+  def attach_fd(arg0, arg1); end
+  def attach_sd(arg0); end
+  def bind_connect_server(arg0, arg1, arg2, arg3); end
+  def close_connection(arg0, arg1); end
+  def connect_server(arg0, arg1); end
+  def connect_unix_server(arg0); end
+  def connection_paused?(arg0); end
+  def current_time; end
+  def detach_fd(arg0); end
+  def epoll; end
+  def epoll=(arg0); end
+  def epoll?; end
+  def get_cipher_bits(arg0); end
+  def get_cipher_name(arg0); end
+  def get_cipher_protocol(arg0); end
+  def get_comm_inactivity_timeout(arg0); end
+  def get_connection_count; end
+  def get_file_descriptor(arg0); end
+  def get_heartbeat_interval; end
+  def get_idle_time(arg0); end
+  def get_max_timer_count; end
+  def get_peer_cert(arg0); end
+  def get_peername(arg0); end
+  def get_pending_connect_timeout(arg0); end
+  def get_proxied_bytes(arg0); end
+  def get_simultaneous_accept_count; end
+  def get_sni_hostname(arg0); end
+  def get_sock_opt(arg0, arg1, arg2); end
+  def get_sockname(arg0); end
+  def get_subprocess_pid(arg0); end
+  def get_subprocess_status(arg0); end
+  def initialize_event_machine; end
+  def invoke_popen(arg0); end
+  def is_notify_readable(arg0); end
+  def is_notify_writable(arg0); end
+  def kqueue; end
+  def kqueue=(arg0); end
+  def kqueue?; end
+  def library_type; end
+  def num_close_scheduled; end
+  def open_udp_socket(arg0, arg1); end
+  def pause_connection(arg0); end
+  def read_keyboard; end
+  def release_machine; end
+  def report_connection_error_status(arg0); end
+  def resume_connection(arg0); end
+  def run_machine; end
+  def run_machine_once; end
+  def run_machine_without_threads; end
+  def self.Callback(object = nil, method = nil, &blk); end
+  def self._open_file_for_writing(filename, handler = nil); end
+  def self.add_oneshot_timer(arg0); end
+  def self.add_periodic_timer(*args, &block); end
+  def self.add_shutdown_hook(&block); end
+  def self.add_timer(*args, &block); end
+  def self.attach(io, handler = nil, *args, &blk); end
+  def self.attach_fd(arg0, arg1); end
+  def self.attach_io(io, watch_mode, handler = nil, *args); end
+  def self.attach_sd(arg0); end
+  def self.attach_server(sock, handler = nil, *args, &block); end
+  def self.bind_connect(bind_addr, bind_port, server, port = nil, handler = nil, *args); end
+  def self.bind_connect_server(arg0, arg1, arg2, arg3); end
+  def self.cancel_timer(timer_or_sig); end
+  def self.cleanup_machine; end
+  def self.close_connection(arg0, arg1); end
+  def self.connect(server, port = nil, handler = nil, *args, &blk); end
+  def self.connect_server(arg0, arg1); end
+  def self.connect_unix_domain(socketname, *args, &blk); end
+  def self.connect_unix_server(arg0); end
+  def self.connection_count; end
+  def self.connection_paused?(arg0); end
+  def self.current_time; end
+  def self.defer(op = nil, callback = nil, errback = nil, &blk); end
+  def self.defers_finished?; end
+  def self.detach_fd(arg0); end
+  def self.disable_proxy(from); end
+  def self.enable_proxy(from, to, bufsize = nil, length = nil); end
+  def self.epoll; end
+  def self.epoll=(arg0); end
+  def self.epoll?; end
+  def self.error_handler(cb = nil, &blk); end
+  def self.event_callback(conn_binding, opcode, data); end
+  def self.fork_reactor(&block); end
+  def self.get_cipher_bits(arg0); end
+  def self.get_cipher_name(arg0); end
+  def self.get_cipher_protocol(arg0); end
+  def self.get_comm_inactivity_timeout(arg0); end
+  def self.get_connection_count; end
+  def self.get_file_descriptor(arg0); end
+  def self.get_heartbeat_interval; end
+  def self.get_idle_time(arg0); end
+  def self.get_max_timer_count; end
+  def self.get_max_timers; end
+  def self.get_peer_cert(arg0); end
+  def self.get_peername(arg0); end
+  def self.get_pending_connect_timeout(arg0); end
+  def self.get_proxied_bytes(arg0); end
+  def self.get_simultaneous_accept_count; end
+  def self.get_sni_hostname(arg0); end
+  def self.get_sock_opt(arg0, arg1, arg2); end
+  def self.get_sockname(arg0); end
+  def self.get_subprocess_pid(arg0); end
+  def self.get_subprocess_status(arg0); end
+  def self.heartbeat_interval; end
+  def self.heartbeat_interval=(time); end
+  def self.initialize_event_machine; end
+  def self.invoke_popen(arg0); end
+  def self.is_notify_readable(arg0); end
+  def self.is_notify_writable(arg0); end
+  def self.klass_from_handler(klass = nil, handler = nil, *args); end
+  def self.kqueue; end
+  def self.kqueue=(arg0); end
+  def self.kqueue?; end
+  def self.library_type; end
+  def self.next_tick(pr = nil, &block); end
+  def self.num_close_scheduled; end
+  def self.open_datagram_socket(address, port, handler = nil, *args); end
+  def self.open_keyboard(handler = nil, *args); end
+  def self.open_udp_socket(arg0, arg1); end
+  def self.pause_connection(arg0); end
+  def self.popen(cmd, handler = nil, *args); end
+  def self.reactor_running?; end
+  def self.reactor_thread; end
+  def self.reactor_thread?; end
+  def self.read_keyboard; end
+  def self.reconnect(server, port, handler); end
+  def self.release_machine; end
+  def self.report_connection_error_status(arg0); end
+  def self.resume_connection(arg0); end
+  def self.run(blk = nil, tail = nil, &block); end
+  def self.run_block(&block); end
+  def self.run_deferred_callbacks; end
+  def self.run_machine; end
+  def self.run_machine_once; end
+  def self.run_machine_without_threads; end
+  def self.schedule(*a, &b); end
+  def self.send_data(arg0, arg1, arg2); end
+  def self.send_datagram(arg0, arg1, arg2, arg3, arg4); end
+  def self.send_file_data(arg0, arg1); end
+  def self.set_comm_inactivity_timeout(arg0, arg1); end
+  def self.set_descriptor_table_size(n_descriptors = nil); end
+  def self.set_effective_user(username); end
+  def self.set_heartbeat_interval(arg0); end
+  def self.set_max_timer_count(arg0); end
+  def self.set_max_timers(ct); end
+  def self.set_notify_readable(arg0, arg1); end
+  def self.set_notify_writable(arg0, arg1); end
+  def self.set_pending_connect_timeout(arg0, arg1); end
+  def self.set_quantum(mills); end
+  def self.set_rlimit_nofile(arg0); end
+  def self.set_simultaneous_accept_count(arg0); end
+  def self.set_sock_opt(arg0, arg1, arg2, arg3); end
+  def self.set_timer_quantum(arg0); end
+  def self.set_tls_parms(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); end
+  def self.setuid_string(arg0); end
+  def self.signal_loopbreak; end
+  def self.spawn(&block); end
+  def self.spawn_threadpool; end
+  def self.ssl?; end
+  def self.start_proxy(arg0, arg1, arg2, arg3); end
+  def self.start_server(server, port = nil, handler = nil, *args, &block); end
+  def self.start_tcp_server(arg0, arg1); end
+  def self.start_tls(arg0); end
+  def self.start_unix_domain_server(filename, *args, &block); end
+  def self.start_unix_server(arg0); end
+  def self.stop; end
+  def self.stop_event_loop; end
+  def self.stop_proxy(arg0); end
+  def self.stop_server(signature); end
+  def self.stop_tcp_server(arg0); end
+  def self.stopping?; end
+  def self.system(cmd, *args, &cb); end
+  def self.threadpool; end
+  def self.threadpool_size; end
+  def self.threadpool_size=(arg0); end
+  def self.tick_loop(*a, &b); end
+  def self.unwatch_filename(arg0); end
+  def self.unwatch_pid(arg0); end
+  def self.watch(io, handler = nil, *args, &blk); end
+  def self.watch_file(filename, handler = nil, *args); end
+  def self.watch_filename(arg0); end
+  def self.watch_pid(arg0); end
+  def self.watch_process(pid, handler = nil, *args); end
+  def self.yield(&block); end
+  def self.yield_and_notify(&block); end
+  def send_data(arg0, arg1, arg2); end
+  def send_datagram(arg0, arg1, arg2, arg3, arg4); end
+  def send_file_data(arg0, arg1); end
+  def set_comm_inactivity_timeout(arg0, arg1); end
+  def set_heartbeat_interval(arg0); end
+  def set_max_timer_count(arg0); end
+  def set_notify_readable(arg0, arg1); end
+  def set_notify_writable(arg0, arg1); end
+  def set_pending_connect_timeout(arg0, arg1); end
+  def set_rlimit_nofile(arg0); end
+  def set_simultaneous_accept_count(arg0); end
+  def set_sock_opt(arg0, arg1, arg2, arg3); end
+  def set_timer_quantum(arg0); end
+  def set_tls_parms(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); end
+  def setuid_string(arg0); end
+  def signal_loopbreak; end
+  def ssl?; end
+  def start_proxy(arg0, arg1, arg2, arg3); end
+  def start_tcp_server(arg0, arg1); end
+  def start_tls(arg0); end
+  def start_unix_server(arg0); end
+  def stop; end
+  def stop_proxy(arg0); end
+  def stop_tcp_server(arg0); end
+  def stopping?; end
+  def unwatch_filename(arg0); end
+  def unwatch_pid(arg0); end
+  def watch_filename(arg0); end
+  def watch_pid(arg0); end
+end
+class EventMachine::Connection
+  def associate_callback_target(arg0); end
+  def close_connection(after_writing = nil); end
+  def close_connection_after_writing; end
+  def comm_inactivity_timeout; end
+  def comm_inactivity_timeout=(value); end
+  def connection_completed; end
+  def detach; end
+  def error?; end
+  def get_cipher_bits; end
+  def get_cipher_name; end
+  def get_cipher_protocol; end
+  def get_idle_time; end
+  def get_outbound_data_size; end
+  def get_peer_cert; end
+  def get_peername; end
+  def get_pid; end
+  def get_proxied_bytes; end
+  def get_sni_hostname; end
+  def get_sock_opt(level, option); end
+  def get_sockname; end
+  def get_status; end
+  def initialize(*args); end
+  def notify_readable=(mode); end
+  def notify_readable?; end
+  def notify_writable=(mode); end
+  def notify_writable?; end
+  def original_method(arg0); end
+  def pause; end
+  def paused?; end
+  def pending_connect_timeout; end
+  def pending_connect_timeout=(value); end
+  def post_init; end
+  def proxy_completed; end
+  def proxy_incoming_to(conn, bufsize = nil); end
+  def proxy_target_unbound; end
+  def receive_data(data); end
+  def reconnect(server, port); end
+  def resume; end
+  def self.new(sig, *args); end
+  def send_data(data); end
+  def send_datagram(data, recipient_address, recipient_port); end
+  def send_file_data(filename); end
+  def set_comm_inactivity_timeout(value); end
+  def set_pending_connect_timeout(value); end
+  def set_sock_opt(level, optname, optval); end
+  def signature; end
+  def signature=(arg0); end
+  def ssl_handshake_completed; end
+  def ssl_verify_peer(cert); end
+  def start_tls(args = nil); end
+  def stop_proxying; end
+  def stream_file_data(filename, args = nil); end
+  def unbind; end
+end
+class EventMachine::Pool
+  def add(resource); end
+  def completion(deferrable, resource); end
+  def contents; end
+  def failure(resource); end
+  def initialize; end
+  def num_waiting; end
+  def on_error(*a, &b); end
+  def perform(*a, &b); end
+  def process(work, resource); end
+  def remove(resource); end
+  def removed?(resource); end
+  def requeue(resource); end
+  def reschedule(*a, &b); end
+end
+module EventMachine::Deferrable
+  def callback(&block); end
+  def cancel_callback(block); end
+  def cancel_errback(block); end
+  def cancel_timeout; end
+  def errback(&block); end
+  def fail(*args); end
+  def self.future(arg, cb = nil, eb = nil, &blk); end
+  def set_deferred_failure(*args); end
+  def set_deferred_status(status, *args); end
+  def set_deferred_success(*args); end
+  def succeed(*args); end
+  def timeout(seconds, *args); end
+end
+class EventMachine::DefaultDeferrable
+  include EventMachine::Deferrable
+end
+class EventMachine::FileStreamer
+  def ensure_mapping_extension_is_present; end
+  def initialize(connection, filename, args = nil); end
+  def stream_one_chunk; end
+  def stream_with_mapping(filename); end
+  def stream_without_mapping(filename); end
+  include EventMachine::Deferrable
+end
+class EventMachine::SpawnedProcess
+  def notify(*x); end
+  def resume(*x); end
+  def run(*x); end
+  def set_receiver(blk); end
+end
+class EventMachine::YieldBlockFromSpawnedProcess
+  def initialize(block, notify); end
+  def pull_out_yield_block; end
+end
+class EventMachine::DeferrableChildProcess < EventMachine::Connection
+  def initialize; end
+  def receive_data(data); end
+  def self.open(cmd); end
+  def unbind; end
+  include EventMachine::Deferrable
+end
+class EventMachine::SystemCmd < EventMachine::Connection
+  def initialize(cb); end
+  def receive_data(data); end
+  def unbind; end
+end
+class EventMachine::Iterator
+  def concurrency; end
+  def concurrency=(val); end
+  def each(foreach = nil, after = nil, &blk); end
+  def initialize(list, concurrency = nil); end
+  def inject(obj, foreach, after); end
+  def map(foreach, after); end
+  def next_item; end
+  def spawn_workers; end
+end
+class BufferedTokenizer
+  def extract(data); end
+  def flush; end
+  def initialize(delimiter = nil); end
+end
+class EventMachine::Timer
+  def cancel; end
+  def initialize(interval, callback = nil, &block); end
+end
+class EventMachine::PeriodicTimer
+  def cancel; end
+  def fire; end
+  def initialize(interval, callback = nil, &block); end
+  def interval; end
+  def interval=(arg0); end
+  def schedule; end
+end
+module EventMachine::Protocols
+end
+class EventMachine::FileNotFoundException < Exception
+end
+class EventMachine::Queue
+  def <<(*items); end
+  def empty?; end
+  def initialize; end
+  def num_waiting; end
+  def pop(*a, &b); end
+  def push(*items); end
+  def size; end
+end
+class EventMachine::Channel
+  def <<(*items); end
+  def gen_id; end
+  def initialize; end
+  def num_subscribers; end
+  def pop(*a, &b); end
+  def push(*items); end
+  def subscribe(*a, &b); end
+  def unsubscribe(name); end
+end
+class EventMachine::FileWatch < EventMachine::Connection
+  def file_deleted; end
+  def file_modified; end
+  def file_moved; end
+  def path; end
+  def receive_data(data); end
+  def stop_watching; end
+end
+class EventMachine::ProcessWatch < EventMachine::Connection
+  def pid; end
+  def process_exited; end
+  def process_forked; end
+  def receive_data(data); end
+  def stop_watching; end
+end
+class EventMachine::TickLoop
+  def initialize(*a, &b); end
+  def on_stop(*a, &b); end
+  def schedule; end
+  def start; end
+  def stop; end
+  def stopped?; end
+end
+module EventMachine::DNS
+end
+class EventMachine::DNS::Resolver
+  def self.hosts; end
+  def self.nameserver; end
+  def self.nameservers; end
+  def self.nameservers=(ns); end
+  def self.resolve(hostname); end
+  def self.socket; end
+  def self.windows?; end
+end
+class EventMachine::DNS::RequestIdAlreadyUsed < RuntimeError
+end
+class EventMachine::DNS::Socket < EventMachine::Connection
+  def deregister_request(id, req); end
+  def initialize; end
+  def nameserver; end
+  def nameserver=(ns); end
+  def post_init; end
+  def receive_data(data); end
+  def register_request(id, req); end
+  def self.open; end
+  def send_packet(pkt); end
+  def start_timer; end
+  def stop_timer; end
+  def tick; end
+  def unbind; end
+end
+class EventMachine::DNS::Request
+  def id; end
+  def initialize(socket, hostname); end
+  def max_tries; end
+  def max_tries=(arg0); end
+  def packet; end
+  def receive_answer(msg); end
+  def retry_interval; end
+  def retry_interval=(arg0); end
+  def send; end
+  def tick; end
+  include EventMachine::Deferrable
+end
+class EventMachine::Completion
+  def callback(*a, &b); end
+  def cancel_callback(*a, &b); end
+  def cancel_errback(*a, &b); end
+  def cancel_timeout; end
+  def change_state(state, *args); end
+  def clear_dead_callbacks; end
+  def completed?; end
+  def completion(*a, &b); end
+  def completion_states; end
+  def errback(*a, &b); end
+  def execute_callbacks; end
+  def execute_state_callbacks(state); end
+  def fail(*args); end
+  def initialize; end
+  def set_deferred_failure(*args); end
+  def set_deferred_status(state, *args); end
+  def set_deferred_success(*args); end
+  def state; end
+  def stateback(state, *a, &b); end
+  def succeed(*args); end
+  def timeout(time, *args); end
+  def value; end
+  include EventMachine::Deferrable
+end
+class EventMachine::ThreadedResource
+  def dispatch; end
+  def initialize; end
+  def shutdown; end
+end