dry-monads-sorbet 1.1.6 → 1.1.7

data/sorbet/rbi/gems/sqlite3.rbi

@@ -1,354 +0,0 @@
-# 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/sqlite3/all/sqlite3.rbi
-#
-# sqlite3-1.4.2
-
-class SQLite3::Database
-  def authorizer(&block); end
-  def authorizer=(arg0); end
-  def busy_handler(*arg0); end
-  def busy_timeout(arg0); end
-  def busy_timeout=(arg0); end
-  def changes; end
-  def close; end
-  def closed?; end
-  def collation(arg0, arg1); end
-  def collations; end
-  def commit; end
-  def complete?(arg0); end
-  def create_aggregate(name, arity, step = nil, finalize = nil, text_rep = nil, &block); end
-  def create_aggregate_handler(handler); end
-  def create_function(name, arity, text_rep = nil, &block); end
-  def db_filename(arg0); end
-  def define_aggregator(name, aggregator); end
-  def define_aggregator2(arg0, arg1); end
-  def define_function(arg0); end
-  def define_function_with_flags(arg0, arg1); end
-  def enable_load_extension(arg0); end
-  def encoding; end
-  def errcode; end
-  def errmsg; end
-  def exec_batch(arg0, arg1); end
-  def execute(sql, bind_vars = nil, *args, &block); end
-  def execute2(sql, *bind_vars); end
-  def execute_batch(sql, bind_vars = nil, *args); end
-  def execute_batch2(sql, &block); end
-  def extended_result_codes=(arg0); end
-  def filename(db_name = nil); end
-  def get_first_row(sql, *bind_vars); end
-  def get_first_value(sql, *bind_vars); end
-  def initialize(file, options = nil, zvfs = nil); end
-  def interrupt; end
-  def last_insert_row_id; end
-  def load_extension(arg0); end
-  def make_type_translator(should_translate); end
-  def open16(arg0); end
-  def open_v2(arg0, arg1, arg2); end
-  def prepare(sql); end
-  def query(sql, bind_vars = nil, *args); end
-  def readonly?; end
-  def results_as_hash; end
-  def results_as_hash=(arg0); end
-  def rollback; end
-  def self.open(*arg0); end
-  def self.quote(string); end
-  def total_changes; end
-  def trace(*arg0); end
-  def transaction(mode = nil); end
-  def transaction_active?; end
-  def translate_from_db(types, row); end
-  def translator; end
-  def type_translation; end
-  def type_translation=(value); end
-  include SQLite3::Pragmas
-end
-class SQLite3::Statement
-  def active?; end
-  def bind_param(arg0, arg1); end
-  def bind_parameter_count; end
-  def bind_params(*bind_vars); end
-  def clear_bindings!; end
-  def close; end
-  def closed?; end
-  def column_count; end
-  def column_decltype(arg0); end
-  def column_name(arg0); end
-  def columns; end
-  def database_name(arg0); end
-  def done?; end
-  def each; end
-  def execute!(*bind_vars, &block); end
-  def execute(*bind_vars); end
-  def get_metadata; end
-  def initialize(arg0, arg1); end
-  def must_be_open!; end
-  def remainder; end
-  def reset!; end
-  def step; end
-  def types; end
-  include Enumerable
-end
-class SQLite3::Backup
-  def finish; end
-  def initialize(arg0, arg1, arg2, arg3); end
-  def pagecount; end
-  def remaining; end
-  def step(arg0); end
-end
-module SQLite3
-  def self.const_missing(name); end
-  def self.libversion; end
-  def self.sqlcipher?; end
-  def self.threadsafe; end
-  def self.threadsafe?; end
-end
-module SQLite3::Constants
-end
-module SQLite3::Constants::TextRep
-end
-module SQLite3::Constants::ColumnType
-end
-module SQLite3::Constants::ErrorCode
-end
-class SQLite3::Exception < StandardError
-  def code; end
-end
-class SQLite3::SQLException < SQLite3::Exception
-end
-class SQLite3::InternalException < SQLite3::Exception
-end
-class SQLite3::PermissionException < SQLite3::Exception
-end
-class SQLite3::AbortException < SQLite3::Exception
-end
-class SQLite3::BusyException < SQLite3::Exception
-end
-class SQLite3::LockedException < SQLite3::Exception
-end
-class SQLite3::MemoryException < SQLite3::Exception
-end
-class SQLite3::ReadOnlyException < SQLite3::Exception
-end
-class SQLite3::InterruptException < SQLite3::Exception
-end
-class SQLite3::IOException < SQLite3::Exception
-end
-class SQLite3::CorruptException < SQLite3::Exception
-end
-class SQLite3::NotFoundException < SQLite3::Exception
-end
-class SQLite3::FullException < SQLite3::Exception
-end
-class SQLite3::CantOpenException < SQLite3::Exception
-end
-class SQLite3::ProtocolException < SQLite3::Exception
-end
-class SQLite3::EmptyException < SQLite3::Exception
-end
-class SQLite3::SchemaChangedException < SQLite3::Exception
-end
-class SQLite3::TooBigException < SQLite3::Exception
-end
-class SQLite3::ConstraintException < SQLite3::Exception
-end
-class SQLite3::MismatchException < SQLite3::Exception
-end
-class SQLite3::MisuseException < SQLite3::Exception
-end
-class SQLite3::UnsupportedException < SQLite3::Exception
-end
-class SQLite3::AuthorizationException < SQLite3::Exception
-end
-class SQLite3::FormatException < SQLite3::Exception
-end
-class SQLite3::RangeException < SQLite3::Exception
-end
-class SQLite3::NotADatabaseException < SQLite3::Exception
-end
-module SQLite3::Pragmas
-  def application_id; end
-  def application_id=(integer); end
-  def auto_vacuum; end
-  def auto_vacuum=(mode); end
-  def automatic_index; end
-  def automatic_index=(mode); end
-  def busy_timeout; end
-  def busy_timeout=(milliseconds); end
-  def cache_size; end
-  def cache_size=(size); end
-  def cache_spill; end
-  def cache_spill=(mode); end
-  def case_sensitive_like=(mode); end
-  def cell_size_check; end
-  def cell_size_check=(mode); end
-  def checkpoint_fullfsync; end
-  def checkpoint_fullfsync=(mode); end
-  def collation_list(&block); end
-  def compile_options(&block); end
-  def count_changes; end
-  def count_changes=(mode); end
-  def data_version; end
-  def database_list(&block); end
-  def default_cache_size; end
-  def default_cache_size=(size); end
-  def default_synchronous; end
-  def default_synchronous=(mode); end
-  def default_temp_store; end
-  def default_temp_store=(mode); end
-  def defer_foreign_keys; end
-  def defer_foreign_keys=(mode); end
-  def encoding; end
-  def encoding=(mode); end
-  def foreign_key_check(*table, &block); end
-  def foreign_key_list(table, &block); end
-  def foreign_keys; end
-  def foreign_keys=(mode); end
-  def freelist_count; end
-  def full_column_names; end
-  def full_column_names=(mode); end
-  def fullfsync; end
-  def fullfsync=(mode); end
-  def get_boolean_pragma(name); end
-  def get_enum_pragma(name); end
-  def get_int_pragma(name); end
-  def get_query_pragma(name, *parms, &block); end
-  def ignore_check_constraints=(mode); end
-  def incremental_vacuum(pages, &block); end
-  def index_info(index, &block); end
-  def index_list(table, &block); end
-  def index_xinfo(index, &block); end
-  def integrity_check(*num_errors, &block); end
-  def journal_mode; end
-  def journal_mode=(mode); end
-  def journal_size_limit; end
-  def journal_size_limit=(size); end
-  def legacy_file_format; end
-  def legacy_file_format=(mode); end
-  def locking_mode; end
-  def locking_mode=(mode); end
-  def max_page_count; end
-  def max_page_count=(size); end
-  def mmap_size; end
-  def mmap_size=(size); end
-  def page_count; end
-  def page_size; end
-  def page_size=(size); end
-  def parser_trace=(mode); end
-  def query_only; end
-  def query_only=(mode); end
-  def quick_check(*num_errors, &block); end
-  def read_uncommitted; end
-  def read_uncommitted=(mode); end
-  def recursive_triggers; end
-  def recursive_triggers=(mode); end
-  def reverse_unordered_selects; end
-  def reverse_unordered_selects=(mode); end
-  def schema_cookie; end
-  def schema_cookie=(cookie); end
-  def schema_version; end
-  def schema_version=(version); end
-  def secure_delete; end
-  def secure_delete=(mode); end
-  def set_boolean_pragma(name, mode); end
-  def set_enum_pragma(name, mode, enums); end
-  def set_int_pragma(name, value); end
-  def short_column_names; end
-  def short_column_names=(mode); end
-  def shrink_memory; end
-  def soft_heap_limit; end
-  def soft_heap_limit=(mode); end
-  def stats(&block); end
-  def synchronous; end
-  def synchronous=(mode); end
-  def table_info(table); end
-  def temp_store; end
-  def temp_store=(mode); end
-  def threads; end
-  def threads=(count); end
-  def tweak_default(hash); end
-  def user_cookie; end
-  def user_cookie=(cookie); end
-  def user_version; end
-  def user_version=(version); end
-  def vdbe_addoptrace=(mode); end
-  def vdbe_debug=(mode); end
-  def vdbe_listing=(mode); end
-  def vdbe_trace; end
-  def vdbe_trace=(mode); end
-  def version_compare(v1, v2); end
-  def wal_autocheckpoint; end
-  def wal_autocheckpoint=(mode); end
-  def wal_checkpoint; end
-  def wal_checkpoint=(mode); end
-  def writable_schema=(mode); end
-end
-class SQLite3::ResultSet
-  def close; end
-  def closed?; end
-  def columns; end
-  def each; end
-  def each_hash; end
-  def eof?; end
-  def initialize(db, stmt); end
-  def next; end
-  def next_hash; end
-  def reset(*bind_params); end
-  def types; end
-  include Enumerable
-end
-class SQLite3::ResultSet::ArrayWithTypes < Array
-  def types; end
-  def types=(arg0); end
-end
-class SQLite3::ResultSet::ArrayWithTypesAndFields < Array
-  def fields; end
-  def fields=(arg0); end
-  def types; end
-  def types=(arg0); end
-end
-class SQLite3::ResultSet::HashWithTypesAndFields < Hash
-  def [](key); end
-  def fields; end
-  def fields=(arg0); end
-  def types; end
-  def types=(arg0); end
-end
-class String
-  def to_blob; end
-end
-class SQLite3::Translator
-  def add_translator(type, &block); end
-  def initialize; end
-  def register_default_translators; end
-  def translate(type, value); end
-  def type_name(type); end
-end
-class SQLite3::Value
-  def handle; end
-  def initialize(db, handle); end
-  def length(utf16 = nil); end
-  def null?; end
-  def to_blob; end
-  def to_f; end
-  def to_i; end
-  def to_int64; end
-  def to_s(utf16 = nil); end
-  def type; end
-end
-class SQLite3::Database::FunctionProxy
-  def [](key); end
-  def []=(key, value); end
-  def count; end
-  def initialize; end
-  def result; end
-  def result=(arg0); end
-  def set_error(error); end
-end
-module SQLite3::VersionProxy
-end

data/sorbet/rbi/gems/stackprof.rbi

@@ -1,52 +0,0 @@
-# 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/stackprof/all/stackprof.rbi
-#
-# stackprof-0.2.15
-
-module StackProf
-  def self.results(*arg0); end
-  def self.run(*arg0); end
-  def self.running?; end
-  def self.sample; end
-  def self.start(*arg0); end
-  def self.stop; end
-end
-class StackProf::Report
-  def +(other); end
-  def add_lines(a, b); end
-  def callers_for(addr); end
-  def convert_to_d3_flame_graph_format(name, stacks, depth); end
-  def data; end
-  def files; end
-  def flamegraph_row(f, x, y, weight, addr); end
-  def frames(sort_by_total = nil); end
-  def initialize(data); end
-  def max_samples; end
-  def modeline; end
-  def normalized_frames; end
-  def overall_samples; end
-  def print_alphabetical_flamegraph(f = nil, skip_common = nil); end
-  def print_callgrind(f = nil); end
-  def print_d3_flamegraph(f = nil, skip_common = nil); end
-  def print_debug; end
-  def print_dump(f = nil); end
-  def print_file(filter, f = nil); end
-  def print_files(sort_by_total = nil, limit = nil, f = nil); end
-  def print_flamegraph(f, skip_common, alphabetical = nil); end
-  def print_graphviz(options = nil, f = nil); end
-  def print_json(f = nil); end
-  def print_method(name, f = nil); end
-  def print_stackcollapse; end
-  def print_text(sort_by_total = nil, limit = nil, select_files = nil, reject_files = nil, select_names = nil, reject_names = nil, f = nil); end
-  def print_timeline_flamegraph(f = nil, skip_common = nil); end
-  def root_frames; end
-  def source_display(f, file, lines, range = nil); end
-  def version; end
-  def walk_method(name); end
-end

data/sorbet/rbi/gems/thor.rbi

@@ -1,32 +0,0 @@
-# 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/thor/all/thor.rbi
-#
-# thor-1.0.1
-
-class Thor
-end
-module Thor::CoreExt
-end
-class Thor::CoreExt::HashWithIndifferentAccess < Hash
-  def [](key); end
-  def []=(key, value); end
-  def convert_key(key); end
-  def delete(key); end
-  def fetch(key, *args); end
-  def initialize(hash = nil); end
-  def key?(key); end
-  def merge!(other); end
-  def merge(other); end
-  def method_missing(method, *args); end
-  def replace(other_hash); end
-  def reverse_merge!(other_hash); end
-  def reverse_merge(other); end
-  def to_hash; end
-  def values_at(*indices); end
-end

data/sorbet/rbi/gems/thread_safe.rbi

@@ -1,82 +0,0 @@
-# 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/thread_safe/all/thread_safe.rbi
-#
-# thread_safe-0.3.6
-
-module ThreadSafe
-end
-module Threadsafe
-  def self.const_missing(name); end
-end
-class SynchronizedDelegator < SimpleDelegator
-  def initialize(obj); end
-  def method_missing(method, *args, &block); end
-  def setup; end
-  def teardown; end
-end
-class ThreadSafe::NonConcurrentCacheBackend
-  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
-  def value?(value); end
-end
-class ThreadSafe::MriCacheBackend < ThreadSafe::NonConcurrentCacheBackend
-  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 ThreadSafe::Cache < ThreadSafe::MriCacheBackend
-  def [](key); end
-  def each_key; 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 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 values; end
-end

data/sorbet/rbi/gems/timecop.rbi

@@ -1,98 +0,0 @@
-# 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/timecop/all/timecop.rbi
-#
-# timecop-0.9.1
-
-class Time
-  def self.mock_time; end
-  def self.new(*args); end
-  def self.new_with_mock_time(*args); end
-  def self.new_without_mock_time(*arg0); end
-  def self.now_with_mock_time; end
-  def self.now_without_mock_time; end
-end
-class Date
-  def self.closest_wday(wday); end
-  def self.mock_date; end
-  def self.mocked_time_stack_item; end
-  def self.parse_with_mock_date(*args); end
-  def self.parse_without_mock_date(*arg0); end
-  def self.strptime_with_mock_date(str = nil, fmt = nil, start = nil); end
-  def self.strptime_without_mock_date(*arg0); end
-  def self.today_with_mock_date; end
-  def self.today_without_mock_date(*arg0); end
-end
-class DateTime < Date
-  def self.mock_time; end
-  def self.mocked_time_stack_item; end
-  def self.now_with_mock_time; end
-  def self.now_without_mock_time(*arg0); end
-  def self.parse_with_mock_date(*args); end
-  def self.parse_without_mock_date(*arg0); end
-end
-class Timecop
-  def baseline; end
-  def baseline=(b); end
-  def initialize; end
-  def return(&block); end
-  def return_to_baseline; end
-  def self.allocate; end
-  def self.baseline; end
-  def self.baseline=(baseline); end
-  def self.freeze(*args, &block); end
-  def self.frozen?; end
-  def self.instance; end
-  def self.new(*arg0); end
-  def self.return(&block); end
-  def self.return_to_baseline; end
-  def self.safe_mode=(safe); end
-  def self.safe_mode?; end
-  def self.scale(*args, &block); end
-  def self.send_travel(mock_type, *args, &block); end
-  def self.thread_safe; end
-  def self.thread_safe=(t); end
-  def self.top_stack_item; end
-  def self.travel(*args, &block); end
-  def set_baseline(b); end
-  def set_stack(s); end
-  def stack; end
-  def thread_safe; end
-  def thread_safe=(t); end
-  def travel(mock_type, *args, &block); end
-  def unmock!; end
-  extend Singleton::SingletonClassMethods
-  include Singleton
-end
-class Timecop::TimeStackItem
-  def compute_travel_offset; end
-  def date(date_klass = nil); end
-  def datetime(datetime_klass = nil); end
-  def day; end
-  def hour; end
-  def initialize(mock_type, *args); end
-  def min; end
-  def mock_type; end
-  def month; end
-  def parse_time(*args); end
-  def rational_to_utc_offset(rational); end
-  def scaled_time; end
-  def scaling_factor; end
-  def sec; end
-  def time(time_klass = nil); end
-  def time_klass; end
-  def times_are_equal_within_epsilon(t1, t2, epsilon_in_seconds); end
-  def travel_offset; end
-  def travel_offset_days; end
-  def utc_offset; end
-  def utc_offset_to_rational(utc_offset); end
-  def year; end
-end
-class Timecop::SafeModeException < StandardError
-  def initialize; end
-end