dear_inventory 0.2.0

data/sorbet/rbi/gems/coderay.rbi

@@ -0,0 +1,92 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strong
+#
+# 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/coderay/all/coderay.rbi
+#
+# coderay-1.1.2
+
+module CodeRay
+  def self.coderay_path(*path); end
+  def self.encode(code, lang, format, options = nil); end
+  def self.encode_file(filename, format, options = nil); end
+  def self.encode_tokens(tokens, format, options = nil); end
+  def self.encoder(format, options = nil); end
+  def self.get_scanner_options(options); end
+  def self.highlight(code, lang, options = nil, format = nil); end
+  def self.highlight_file(filename, options = nil, format = nil); end
+  def self.scan(code, lang, options = nil, &block); end
+  def self.scan_file(filename, lang = nil, options = nil, &block); end
+  def self.scanner(lang, options = nil, &block); end
+end
+module CodeRay::PluginHost
+  def [](id, *args, &blk); end
+  def all_plugins; end
+  def const_missing(const); end
+  def default(id = nil); end
+  def list; end
+  def load(id, *args, &blk); end
+  def load_all; end
+  def load_plugin_map; end
+  def make_plugin_hash; end
+  def map(hash); end
+  def path_to(plugin_id); end
+  def plugin_hash; end
+  def plugin_path(*args); end
+  def register(plugin, id); end
+  def self.extended(mod); end
+  def validate_id(id); end
+end
+class CodeRay::PluginHost::PluginNotFound < LoadError
+end
+class CodeRay::PluginHost::HostNotFound < LoadError
+end
+module CodeRay::Encoders
+  extend CodeRay::PluginHost
+end
+module CodeRay::Plugin
+  def aliases; end
+  def plugin_host(host = nil); end
+  def plugin_id; end
+  def register_for(id); end
+  def title(title = nil); end
+end
+class CodeRay::Encoders::Encoder
+  def <<(token); end
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def compile(tokens, options = nil); end
+  def encode(code, lang, options = nil); end
+  def encode_tokens(tokens, options = nil); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def file_extension; end
+  def finish(options); end
+  def get_output(options); end
+  def highlight(code, lang, options = nil); end
+  def initialize(options = nil); end
+  def options; end
+  def options=(arg0); end
+  def output(data); end
+  def scanner; end
+  def scanner=(arg0); end
+  def self.const_missing(sym); end
+  def self.file_extension; end
+  def setup(options); end
+  def text_token(text, kind); end
+  def token(content, kind); end
+  def tokens(tokens, options = nil); end
+  extend CodeRay::Plugin
+end
+class CodeRay::Encoders::Terminal < CodeRay::Encoders::Encoder
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def open_token(kind); end
+  def setup(options); end
+  def text_token(text, kind); end
+end

data/sorbet/rbi/gems/crack.rbi

@@ -0,0 +1,48 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strong
+#
+# 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/crack/all/crack.rbi
+#
+# crack-0.4.3
+
+class REXMLUtiliyNodeString < String
+  def attributes; end
+  def attributes=(arg0); end
+end
+class REXMLUtilityNode
+  def add_node(node); end
+  def attributes; end
+  def attributes=(arg0); end
+  def children; end
+  def children=(arg0); end
+  def initialize(name, normalized_attributes = nil); end
+  def inner_html; end
+  def name; end
+  def name=(arg0); end
+  def self.available_typecasts; end
+  def self.available_typecasts=(obj); end
+  def self.typecasts; end
+  def self.typecasts=(obj); end
+  def to_hash; end
+  def to_html; end
+  def to_s; end
+  def type; end
+  def type=(arg0); end
+  def typecast_value(value); end
+  def undasherize_keys(params); end
+  def unnormalize_xml_entities(value); end
+end
+module Crack
+end
+class Crack::REXMLParser
+  def self.parse(xml); end
+end
+class Crack::XML
+  def self.parse(xml); end
+  def self.parser; end
+  def self.parser=(parser); end
+end

data/sorbet/rbi/gems/domain_name.rbi

@@ -0,0 +1,52 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strong
+#
+# 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/domain_name/all/domain_name.rbi
+#
+# domain_name-0.5.20190701
+
+class DomainName
+  def <(other); end
+  def <=(other); end
+  def <=>(other); end
+  def ==(other); end
+  def >(other); end
+  def >=(other); end
+  def canonical?; end
+  def canonical_tld?; end
+  def cookie_domain?(domain, host_only = nil); end
+  def domain; end
+  def domain_idn; end
+  def hostname; end
+  def hostname_idn; end
+  def idn; end
+  def initialize(hostname); end
+  def inspect; end
+  def ipaddr; end
+  def ipaddr?; end
+  def self.etld_data; end
+  def self.normalize(domain); end
+  def superdomain; end
+  def tld; end
+  def tld_idn; end
+  def to_s; end
+  def to_str; end
+  def uri_host; end
+end
+module DomainName::Punycode
+  def self.decode(string); end
+  def self.decode_hostname(hostname); end
+  def self.encode(string); end
+  def self.encode_hostname(hostname); end
+end
+class DomainName::Punycode::ArgumentError < ArgumentError
+end
+class DomainName::Punycode::BufferOverflowError < DomainName::Punycode::ArgumentError
+end
+class Object < BasicObject
+  def DomainName(hostname); end
+end

data/sorbet/rbi/gems/dotenv.rbi

@@ -0,0 +1,68 @@
+# 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/dotenv/all/dotenv.rbi
+#
+# dotenv-2.7.5
+
+module Dotenv
+  def ignoring_nonexistent_files; end
+  def instrument(name, payload = nil, &block); end
+  def load!(*filenames); end
+  def load(*filenames); end
+  def overload!(*filenames); end
+  def overload(*filenames); end
+  def parse(*filenames); end
+  def require_keys(*keys); end
+  def self.ignoring_nonexistent_files; end
+  def self.instrument(name, payload = nil, &block); end
+  def self.instrumenter; end
+  def self.instrumenter=(arg0); end
+  def self.load!(*filenames); end
+  def self.load(*filenames); end
+  def self.overload!(*filenames); end
+  def self.overload(*filenames); end
+  def self.parse(*filenames); end
+  def self.require_keys(*keys); end
+  def self.with(*filenames); end
+  def with(*filenames); end
+end
+module Dotenv::Substitutions
+end
+module Dotenv::Substitutions::Variable
+  def self.call(value, env, is_load); end
+  def self.substitute(match, variable, env); end
+end
+module Dotenv::Substitutions::Command
+  def self.call(value, _env, _is_load); end
+end
+class Dotenv::FormatError < SyntaxError
+end
+class Dotenv::Parser
+  def call; end
+  def expand_newlines(value); end
+  def initialize(string, is_load = nil); end
+  def parse_line(line); end
+  def parse_value(value); end
+  def self.call(string, is_load = nil); end
+  def self.substitutions; end
+  def unescape_characters(value); end
+  def variable_not_set?(line); end
+end
+class Dotenv::Environment < Hash
+  def apply!; end
+  def apply; end
+  def filename; end
+  def initialize(filename, is_load = nil); end
+  def load(is_load = nil); end
+  def read; end
+end
+class Dotenv::Error < StandardError
+end
+class Dotenv::MissingKeys < Dotenv::Error
+  def initialize(keys); end
+end

data/sorbet/rbi/gems/ffi-compiler.rbi

@@ -0,0 +1,27 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strong
+#
+# 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/ffi-compiler/all/ffi-compiler.rbi
+#
+# ffi-compiler-1.0.1
+
+module FFI::Compiler
+end
+class FFI::Compiler::Platform
+  def arch; end
+  def mac?; end
+  def map_library_name(name); end
+  def name; end
+  def os; end
+  def self.system; end
+end
+module FFI
+end
+module FFI::Compiler::Loader
+  def self.caller_path(line = nil); end
+  def self.find(name, start_path = nil); end
+end

data/sorbet/rbi/gems/ffi.rbi

@@ -0,0 +1,560 @@
+# 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/ffi/all/ffi.rbi
+#
+# ffi-1.12.2
+
+class FFI::Type
+  def alignment; end
+  def initialize(arg0); end
+  def inspect; end
+  def size; end
+end
+class FFI::Type::Builtin < FFI::Type
+  def inspect; end
+end
+class FFI::ArrayType < FFI::Type
+  def elem_type; end
+  def initialize(arg0, arg1); end
+  def length; end
+end
+module FFI::LastError
+  def error; end
+  def error=(arg0); end
+  def self.error; end
+  def self.error=(arg0); end
+end
+class FFI::AbstractMemory
+  def [](arg0); end
+  def __copy_from__(arg0, arg1); end
+  def clear; end
+  def get(arg0, arg1); end
+  def get_array_of_char(arg0, arg1); end
+  def get_array_of_double(arg0, arg1); end
+  def get_array_of_float(arg0, arg1); end
+  def get_array_of_float32(arg0, arg1); end
+  def get_array_of_float64(arg0, arg1); end
+  def get_array_of_int(arg0, arg1); end
+  def get_array_of_int16(arg0, arg1); end
+  def get_array_of_int32(arg0, arg1); end
+  def get_array_of_int64(arg0, arg1); end
+  def get_array_of_int8(arg0, arg1); end
+  def get_array_of_long(arg0, arg1); end
+  def get_array_of_long_long(arg0, arg1); end
+  def get_array_of_pointer(arg0, arg1); end
+  def get_array_of_short(arg0, arg1); end
+  def get_array_of_string(*arg0); end
+  def get_array_of_uchar(arg0, arg1); end
+  def get_array_of_uint(arg0, arg1); end
+  def get_array_of_uint16(arg0, arg1); end
+  def get_array_of_uint32(arg0, arg1); end
+  def get_array_of_uint64(arg0, arg1); end
+  def get_array_of_uint8(arg0, arg1); end
+  def get_array_of_ulong(arg0, arg1); end
+  def get_array_of_ulong_long(arg0, arg1); end
+  def get_array_of_ushort(arg0, arg1); end
+  def get_bytes(arg0, arg1); end
+  def get_char(arg0); end
+  def get_double(arg0); end
+  def get_float(arg0); end
+  def get_float32(arg0); end
+  def get_float64(arg0); end
+  def get_int(arg0); end
+  def get_int16(arg0); end
+  def get_int32(arg0); end
+  def get_int64(arg0); end
+  def get_int8(arg0); end
+  def get_long(arg0); end
+  def get_long_long(arg0); end
+  def get_pointer(arg0); end
+  def get_short(arg0); end
+  def get_string(*arg0); end
+  def get_uchar(arg0); end
+  def get_uint(arg0); end
+  def get_uint16(arg0); end
+  def get_uint32(arg0); end
+  def get_uint64(arg0); end
+  def get_uint8(arg0); end
+  def get_ulong(arg0); end
+  def get_ulong_long(arg0); end
+  def get_ushort(arg0); end
+  def put(arg0, arg1, arg2); end
+  def put_array_of_char(arg0, arg1); end
+  def put_array_of_double(arg0, arg1); end
+  def put_array_of_float(arg0, arg1); end
+  def put_array_of_float32(arg0, arg1); end
+  def put_array_of_float64(arg0, arg1); end
+  def put_array_of_int(arg0, arg1); end
+  def put_array_of_int16(arg0, arg1); end
+  def put_array_of_int32(arg0, arg1); end
+  def put_array_of_int64(arg0, arg1); end
+  def put_array_of_int8(arg0, arg1); end
+  def put_array_of_long(arg0, arg1); end
+  def put_array_of_long_long(arg0, arg1); end
+  def put_array_of_pointer(arg0, arg1); end
+  def put_array_of_short(arg0, arg1); end
+  def put_array_of_uchar(arg0, arg1); end
+  def put_array_of_uint(arg0, arg1); end
+  def put_array_of_uint16(arg0, arg1); end
+  def put_array_of_uint32(arg0, arg1); end
+  def put_array_of_uint64(arg0, arg1); end
+  def put_array_of_uint8(arg0, arg1); end
+  def put_array_of_ulong(arg0, arg1); end
+  def put_array_of_ulong_long(arg0, arg1); end
+  def put_array_of_ushort(arg0, arg1); end
+  def put_bytes(*arg0); end
+  def put_char(arg0, arg1); end
+  def put_double(arg0, arg1); end
+  def put_float(arg0, arg1); end
+  def put_float32(arg0, arg1); end
+  def put_float64(arg0, arg1); end
+  def put_int(arg0, arg1); end
+  def put_int16(arg0, arg1); end
+  def put_int32(arg0, arg1); end
+  def put_int64(arg0, arg1); end
+  def put_int8(arg0, arg1); end
+  def put_long(arg0, arg1); end
+  def put_long_long(arg0, arg1); end
+  def put_pointer(arg0, arg1); end
+  def put_short(arg0, arg1); end
+  def put_string(arg0, arg1); end
+  def put_uchar(arg0, arg1); end
+  def put_uint(arg0, arg1); end
+  def put_uint16(arg0, arg1); end
+  def put_uint32(arg0, arg1); end
+  def put_uint64(arg0, arg1); end
+  def put_uint8(arg0, arg1); end
+  def put_ulong(arg0, arg1); end
+  def put_ulong_long(arg0, arg1); end
+  def put_ushort(arg0, arg1); end
+  def read_array_of_char(arg0); end
+  def read_array_of_double(arg0); end
+  def read_array_of_float(arg0); end
+  def read_array_of_int(arg0); end
+  def read_array_of_int16(arg0); end
+  def read_array_of_int32(arg0); end
+  def read_array_of_int64(arg0); end
+  def read_array_of_int8(arg0); end
+  def read_array_of_long(arg0); end
+  def read_array_of_long_long(arg0); end
+  def read_array_of_pointer(arg0); end
+  def read_array_of_short(arg0); end
+  def read_array_of_uchar(arg0); end
+  def read_array_of_uint(arg0); end
+  def read_array_of_uint16(arg0); end
+  def read_array_of_uint32(arg0); end
+  def read_array_of_uint64(arg0); end
+  def read_array_of_uint8(arg0); end
+  def read_array_of_ulong(arg0); end
+  def read_array_of_ulong_long(arg0); end
+  def read_array_of_ushort(arg0); end
+  def read_bytes(arg0); end
+  def read_char; end
+  def read_double; end
+  def read_float; end
+  def read_int16; end
+  def read_int32; end
+  def read_int64; end
+  def read_int8; end
+  def read_int; end
+  def read_long; end
+  def read_long_long; end
+  def read_pointer; end
+  def read_short; end
+  def read_uchar; end
+  def read_uint16; end
+  def read_uint32; end
+  def read_uint64; end
+  def read_uint8; end
+  def read_uint; end
+  def read_ulong; end
+  def read_ulong_long; end
+  def read_ushort; end
+  def size; end
+  def total; end
+  def type_size; end
+  def write_array_of_char(arg0); end
+  def write_array_of_double(arg0); end
+  def write_array_of_float(arg0); end
+  def write_array_of_int(arg0); end
+  def write_array_of_int16(arg0); end
+  def write_array_of_int32(arg0); end
+  def write_array_of_int64(arg0); end
+  def write_array_of_int8(arg0); end
+  def write_array_of_long(arg0); end
+  def write_array_of_long_long(arg0); end
+  def write_array_of_pointer(arg0); end
+  def write_array_of_short(arg0); end
+  def write_array_of_uchar(arg0); end
+  def write_array_of_uint(arg0); end
+  def write_array_of_uint16(arg0); end
+  def write_array_of_uint32(arg0); end
+  def write_array_of_uint64(arg0); end
+  def write_array_of_uint8(arg0); end
+  def write_array_of_ulong(arg0); end
+  def write_array_of_ulong_long(arg0); end
+  def write_array_of_ushort(arg0); end
+  def write_bytes(*arg0); end
+  def write_char(arg0); end
+  def write_double(arg0); end
+  def write_float(arg0); end
+  def write_int(arg0); end
+  def write_int16(arg0); end
+  def write_int32(arg0); end
+  def write_int64(arg0); end
+  def write_int8(arg0); end
+  def write_long(arg0); end
+  def write_long_long(arg0); end
+  def write_pointer(arg0); end
+  def write_short(arg0); end
+  def write_uchar(arg0); end
+  def write_uint(arg0); end
+  def write_uint16(arg0); end
+  def write_uint32(arg0); end
+  def write_uint64(arg0); end
+  def write_uint8(arg0); end
+  def write_ulong(arg0); end
+  def write_ulong_long(arg0); end
+  def write_ushort(arg0); end
+end
+class FFI::Pointer < FFI::AbstractMemory
+  def +(arg0); end
+  def ==(arg0); end
+  def address; end
+  def autorelease=(arg0); end
+  def autorelease?; end
+  def free; end
+  def initialize(*arg0); end
+  def initialize_copy(arg0); end
+  def inspect; end
+  def null?; end
+  def order(*arg0); end
+  def read(type); end
+  def read_array_of_type(type, reader, length); end
+  def read_string(len = nil); end
+  def read_string_length(len); end
+  def read_string_to_null; end
+  def self.size; end
+  def slice(arg0, arg1); end
+  def to_i; end
+  def to_ptr; end
+  def to_s; end
+  def type_size; end
+  def write(type, value); end
+  def write_array_of_type(type, writer, ary); end
+  def write_string(str, len = nil); end
+  def write_string_length(str, len); end
+end
+class FFI::FunctionType < FFI::Type
+  def initialize(*arg0); end
+  def param_types; end
+  def result_type; end
+end
+class FFI::Function < FFI::Pointer
+  def attach(arg0, arg1); end
+  def autorelease; end
+  def autorelease=(arg0); end
+  def autorelease?; end
+  def call(*arg0); end
+  def free; end
+  def initialize(*arg0); end
+  def initialize_copy(arg0); end
+end
+class FFI::MemoryPointer < FFI::Pointer
+  def initialize(*arg0); end
+  def self.from_string(arg0); end
+end
+class FFI::Buffer < FFI::AbstractMemory
+  def +(arg0); end
+  def initialize(*arg0); end
+  def initialize_copy(arg0); end
+  def inspect; end
+  def length; end
+  def order(*arg0); end
+  def self.alloc_in(*arg0); end
+  def self.alloc_inout(*arg0); end
+  def self.alloc_out(*arg0); end
+  def self.new_in(*arg0); end
+  def self.new_inout(*arg0); end
+  def self.new_out(*arg0); end
+  def slice(arg0, arg1); end
+end
+class FFI::StructByValue < FFI::Type
+  def initialize(arg0); end
+  def layout; end
+  def struct_class; end
+end
+class FFI::StructLayout::Field
+  def alignment; end
+  def get(arg0); end
+  def initialize(*arg0); end
+  def name; end
+  def offset; end
+  def put(arg0, arg1); end
+  def size; end
+  def type; end
+end
+class FFI::StructLayout::Function < FFI::StructLayout::Field
+  def get(arg0); end
+  def put(arg0, arg1); end
+end
+class FFI::StructLayout::Array < FFI::StructLayout::Field
+  def get(arg0); end
+  def put(arg0, arg1); end
+end
+class FFI::StructLayout < FFI::Type
+  def [](arg0); end
+  def __union!; end
+  def fields; end
+  def initialize(arg0, arg1, arg2); end
+  def members; end
+  def offset_of(field_name); end
+  def offsets; end
+  def to_a; end
+end
+class FFI::Struct
+  def [](arg0); end
+  def []=(arg0, arg1); end
+  def align; end
+  def alignment; end
+  def clear; end
+  def initialize(*arg0); end
+  def initialize_copy(arg0); end
+  def layout; end
+  def layout=(arg0); end
+  def members; end
+  def null?; end
+  def offset_of(name); end
+  def offsets; end
+  def order(*arg0); end
+  def pointer; end
+  def pointer=(arg0); end
+  def self.align(alignment = nil); end
+  def self.aligned(alignment = nil); end
+  def self.alignment; end
+  def self.alloc_in(*arg0); end
+  def self.alloc_inout(*arg0); end
+  def self.alloc_out(*arg0); end
+  def self.array_layout(builder, spec); end
+  def self.auto_ptr; end
+  def self.by_ref(flags = nil); end
+  def self.by_value; end
+  def self.callback(params, ret); end
+  def self.enclosing_module; end
+  def self.find_field_type(type, mod = nil); end
+  def self.find_type(type, mod = nil); end
+  def self.hash_layout(builder, spec); end
+  def self.in; end
+  def self.layout(*spec); end
+  def self.members; end
+  def self.new_in(*arg0); end
+  def self.new_inout(*arg0); end
+  def self.new_out(*arg0); end
+  def self.offset_of(name); end
+  def self.offsets; end
+  def self.out; end
+  def self.pack(packed = nil); end
+  def self.packed(packed = nil); end
+  def self.ptr(flags = nil); end
+  def self.size; end
+  def self.size=(size); end
+  def self.val; end
+  def size; end
+  def to_ptr; end
+  def values; end
+end
+class FFI::Struct::InlineArray
+  def [](arg0); end
+  def []=(arg0, arg1); end
+  def each; end
+  def initialize(arg0, arg1); end
+  def size; end
+  def to_a; end
+  def to_ptr; end
+end
+class FFI::StructLayout::CharArray < FFI::Struct::InlineArray
+  def to_s; end
+  def to_str; end
+end
+class FFI::DynamicLibrary
+  def find_function(arg0); end
+  def find_symbol(arg0); end
+  def find_variable(arg0); end
+  def initialize(arg0, arg1); end
+  def last_error; end
+  def name; end
+  def self.last_error; end
+  def self.open(arg0, arg1); end
+end
+class FFI::DynamicLibrary::Symbol < FFI::Pointer
+  def initialize_copy(arg0); end
+  def inspect; end
+end
+class FFI::VariadicInvoker
+  def attach(mod, mname); end
+  def call(*args, &block); end
+  def init(arg_types, type_map); end
+  def initialize(arg0, arg1, arg2, arg3); end
+  def invoke(arg0, arg1); end
+end
+class FFI::Type::Mapped < FFI::Type
+  def from_native(*arg0); end
+  def initialize(arg0); end
+  def native_type; end
+  def to_native(*arg0); end
+  def type; end
+end
+module FFI
+  def self.add_typedef(old, add); end
+  def self.errno; end
+  def self.errno=(error); end
+  def self.find_type(name, type_map = nil); end
+  def self.map_library_name(lib); end
+  def self.type_size(type); end
+  def self.typedef(old, add); end
+end
+class FFI::PlatformError < LoadError
+end
+module FFI::Platform
+  def self.bsd?; end
+  def self.is_os(os); end
+  def self.mac?; end
+  def self.solaris?; end
+  def self.unix?; end
+  def self.windows?; end
+end
+module FFI::DataConverter
+  def from_native(value, ctx); end
+  def native_type(type = nil); end
+  def to_native(value, ctx); end
+end
+class FFI::StrPtrConverter
+  def self.from_native(val, ctx); end
+  extend FFI::DataConverter
+end
+class FFI::NotFoundError < LoadError
+  def initialize(function, *libraries); end
+end
+module FFI::Library
+  def attach_function(name, func, args, returns = nil, options = nil); end
+  def attach_variable(mname, a1, a2 = nil); end
+  def bitmask(*args); end
+  def callback(*args); end
+  def enum(*args); end
+  def enum_type(name); end
+  def enum_value(symbol); end
+  def ffi_convention(convention = nil); end
+  def ffi_lib(*names); end
+  def ffi_lib_flags(*flags); end
+  def ffi_libraries; end
+  def find_type(t); end
+  def function_names(name, arg_types); end
+  def generic_enum(klass, *args); end
+  def self.extended(mod); end
+  def typedef(old, add, info = nil); end
+end
+class FFI::StructLayout::Enum < FFI::StructLayout::Field
+  def get(ptr); end
+  def put(ptr, value); end
+end
+class FFI::StructLayout::InnerStruct < FFI::StructLayout::Field
+  def get(ptr); end
+  def put(ptr, value); end
+end
+class FFI::StructLayout::Mapped < FFI::StructLayout::Field
+  def get(ptr); end
+  def initialize(name, offset, type, orig_field); end
+  def put(ptr, value); end
+end
+class FFI::StructLayoutBuilder
+  def add(name, type, offset = nil); end
+  def add_array(name, type, count, offset = nil); end
+  def add_field(name, type, offset = nil); end
+  def add_struct(name, type, offset = nil); end
+  def align(offset, align); end
+  def alignment; end
+  def alignment=(align); end
+  def build; end
+  def field_for_type(name, offset, type); end
+  def initialize; end
+  def packed=(packed); end
+  def size; end
+  def size=(size); end
+  def union=(is_union); end
+  def union?; end
+end
+class FFI::StructByReference
+  def from_native(value, ctx); end
+  def initialize(struct_class); end
+  def native_type; end
+  def struct_class; end
+  def to_native(value, ctx); end
+  include FFI::DataConverter
+end
+class FFI::Struct::ManagedStructConverter < FFI::StructByReference
+  def from_native(ptr, ctx); end
+  def initialize(struct_class); end
+end
+class FFI::Union < FFI::Struct
+  def self.builder; end
+end
+class FFI::ManagedStruct < FFI::Struct
+  def initialize(pointer = nil); end
+end
+module FFI::IO
+  def self.for_fd(fd, mode = nil); end
+  def self.native_read(io, buf, len); end
+end
+class FFI::AutoPointer < FFI::Pointer
+  def autorelease=(autorelease); end
+  def autorelease?; end
+  def free; end
+  def initialize(ptr, proc = nil, &block); end
+  def self.from_native(val, ctx); end
+  def self.native_type; end
+  extend FFI::DataConverter
+end
+class FFI::AutoPointer::Releaser
+  def autorelease; end
+  def autorelease=(arg0); end
+  def call(*args); end
+  def free; end
+  def initialize(ptr, proc); end
+end
+class FFI::AutoPointer::DefaultReleaser < FFI::AutoPointer::Releaser
+  def release(ptr); end
+end
+class FFI::AutoPointer::CallableReleaser < FFI::AutoPointer::Releaser
+  def release(ptr); end
+end
+class FFI::Enums
+  def <<(enum); end
+  def __map_symbol(symbol); end
+  def find(query); end
+  def initialize; end
+end
+class FFI::Enum
+  def [](query); end
+  def find(query); end
+  def from_native(val, ctx); end
+  def initialize(*args); end
+  def native_type; end
+  def symbol_map; end
+  def symbols; end
+  def tag; end
+  def to_h; end
+  def to_hash; end
+  def to_native(val, ctx); end
+  include FFI::DataConverter
+end
+class FFI::Bitmask < FFI::Enum
+  def [](*query); end
+  def from_native(val, ctx); end
+  def initialize(*args); end
+  def to_native(query, ctx); end
+end