activerecord-ejection_seat 0.1.0 → 0.2.0

data/sorbet/rbi/gems/sqlite3@1.5.4.rbi

@@ -0,0 +1,1600 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `sqlite3` gem.
+# Please instead update this file by running `bin/tapioca gem sqlite3`.
+
+module SQLite3
+  class << self
+    # source://sqlite3//lib/sqlite3/version.rb#16
+    def const_missing(name); end
+
+    def libversion; end
+    def sqlcipher?; end
+    def threadsafe; end
+
+    # Was sqlite3 compiled with thread safety on?
+    #
+    # @return [Boolean]
+    #
+    # source://sqlite3//lib/sqlite3.rb#14
+    def threadsafe?; end
+  end
+end
+
+class SQLite3::AbortException < ::SQLite3::Exception; end
+class SQLite3::AuthorizationException < ::SQLite3::Exception; end
+
+class SQLite3::Backup
+  def initialize(_arg0, _arg1, _arg2, _arg3); end
+
+  def finish; end
+  def pagecount; end
+  def remaining; end
+  def step(_arg0); end
+end
+
+class SQLite3::Blob < ::String; end
+class SQLite3::BusyException < ::SQLite3::Exception; end
+class SQLite3::CantOpenException < ::SQLite3::Exception; end
+module SQLite3::Constants; end
+module SQLite3::Constants::ColumnType; end
+
+# source://sqlite3//lib/sqlite3/constants.rb#16
+SQLite3::Constants::ColumnType::BLOB = T.let(T.unsafe(nil), Integer)
+
+# source://sqlite3//lib/sqlite3/constants.rb#14
+SQLite3::Constants::ColumnType::FLOAT = T.let(T.unsafe(nil), Integer)
+
+# source://sqlite3//lib/sqlite3/constants.rb#13
+SQLite3::Constants::ColumnType::INTEGER = T.let(T.unsafe(nil), Integer)
+
+# source://sqlite3//lib/sqlite3/constants.rb#17
+SQLite3::Constants::ColumnType::NULL = T.let(T.unsafe(nil), Integer)
+
+# source://sqlite3//lib/sqlite3/constants.rb#15
+SQLite3::Constants::ColumnType::TEXT = T.let(T.unsafe(nil), Integer)
+
+module SQLite3::Constants::ErrorCode; end
+
+# Callback routine requested an abort
+#
+# source://sqlite3//lib/sqlite3/constants.rb#25
+SQLite3::Constants::ErrorCode::ABORT = T.let(T.unsafe(nil), Integer)
+
+# Authorization denied
+#
+# source://sqlite3//lib/sqlite3/constants.rb#44
+SQLite3::Constants::ErrorCode::AUTH = T.let(T.unsafe(nil), Integer)
+
+# The database file is locked
+#
+# source://sqlite3//lib/sqlite3/constants.rb#26
+SQLite3::Constants::ErrorCode::BUSY = T.let(T.unsafe(nil), Integer)
+
+# Unable to open the database file
+#
+# source://sqlite3//lib/sqlite3/constants.rb#35
+SQLite3::Constants::ErrorCode::CANTOPEN = T.let(T.unsafe(nil), Integer)
+
+# Abort due to constraint violation
+#
+# source://sqlite3//lib/sqlite3/constants.rb#40
+SQLite3::Constants::ErrorCode::CONSTRAINT = T.let(T.unsafe(nil), Integer)
+
+# The database disk image is malformed
+#
+# source://sqlite3//lib/sqlite3/constants.rb#32
+SQLite3::Constants::ErrorCode::CORRUPT = T.let(T.unsafe(nil), Integer)
+
+# sqlite_step() has finished executing
+#
+# source://sqlite3//lib/sqlite3/constants.rb#47
+SQLite3::Constants::ErrorCode::DONE = T.let(T.unsafe(nil), Integer)
+
+# (Internal Only) Database table is empty
+#
+# source://sqlite3//lib/sqlite3/constants.rb#37
+SQLite3::Constants::ErrorCode::EMPTY = T.let(T.unsafe(nil), Integer)
+
+# SQL error or missing database
+#
+# source://sqlite3//lib/sqlite3/constants.rb#22
+SQLite3::Constants::ErrorCode::ERROR = T.let(T.unsafe(nil), Integer)
+
+# Insertion failed because database is full
+#
+# source://sqlite3//lib/sqlite3/constants.rb#34
+SQLite3::Constants::ErrorCode::FULL = T.let(T.unsafe(nil), Integer)
+
+# An internal logic error in SQLite
+#
+# source://sqlite3//lib/sqlite3/constants.rb#23
+SQLite3::Constants::ErrorCode::INTERNAL = T.let(T.unsafe(nil), Integer)
+
+# Operation terminated by sqlite_interrupt()
+#
+# source://sqlite3//lib/sqlite3/constants.rb#30
+SQLite3::Constants::ErrorCode::INTERRUPT = T.let(T.unsafe(nil), Integer)
+
+# Some kind of disk I/O error occurred
+#
+# source://sqlite3//lib/sqlite3/constants.rb#31
+SQLite3::Constants::ErrorCode::IOERR = T.let(T.unsafe(nil), Integer)
+
+# A table in the database is locked
+#
+# source://sqlite3//lib/sqlite3/constants.rb#27
+SQLite3::Constants::ErrorCode::LOCKED = T.let(T.unsafe(nil), Integer)
+
+# Data type mismatch
+#
+# source://sqlite3//lib/sqlite3/constants.rb#41
+SQLite3::Constants::ErrorCode::MISMATCH = T.let(T.unsafe(nil), Integer)
+
+# Library used incorrectly
+#
+# source://sqlite3//lib/sqlite3/constants.rb#42
+SQLite3::Constants::ErrorCode::MISUSE = T.let(T.unsafe(nil), Integer)
+
+# Uses OS features not supported on host
+#
+# source://sqlite3//lib/sqlite3/constants.rb#43
+SQLite3::Constants::ErrorCode::NOLFS = T.let(T.unsafe(nil), Integer)
+
+# A malloc() failed
+#
+# source://sqlite3//lib/sqlite3/constants.rb#28
+SQLite3::Constants::ErrorCode::NOMEM = T.let(T.unsafe(nil), Integer)
+
+# (Internal Only) Table or record not found
+#
+# source://sqlite3//lib/sqlite3/constants.rb#33
+SQLite3::Constants::ErrorCode::NOTFOUND = T.let(T.unsafe(nil), Integer)
+
+# Successful result
+#
+# source://sqlite3//lib/sqlite3/constants.rb#21
+SQLite3::Constants::ErrorCode::OK = T.let(T.unsafe(nil), Integer)
+
+# Access permission denied
+#
+# source://sqlite3//lib/sqlite3/constants.rb#24
+SQLite3::Constants::ErrorCode::PERM = T.let(T.unsafe(nil), Integer)
+
+# Database lock protocol error
+#
+# source://sqlite3//lib/sqlite3/constants.rb#36
+SQLite3::Constants::ErrorCode::PROTOCOL = T.let(T.unsafe(nil), Integer)
+
+# Attempt to write a readonly database
+#
+# source://sqlite3//lib/sqlite3/constants.rb#29
+SQLite3::Constants::ErrorCode::READONLY = T.let(T.unsafe(nil), Integer)
+
+# sqlite_step() has another row ready
+#
+# source://sqlite3//lib/sqlite3/constants.rb#46
+SQLite3::Constants::ErrorCode::ROW = T.let(T.unsafe(nil), Integer)
+
+# The database schema changed
+#
+# source://sqlite3//lib/sqlite3/constants.rb#38
+SQLite3::Constants::ErrorCode::SCHEMA = T.let(T.unsafe(nil), Integer)
+
+# Too much data for one row of a table
+#
+# source://sqlite3//lib/sqlite3/constants.rb#39
+SQLite3::Constants::ErrorCode::TOOBIG = T.let(T.unsafe(nil), Integer)
+
+module SQLite3::Constants::Open; end
+SQLite3::Constants::Open::AUTOPROXY = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::CREATE = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::DELETEONCLOSE = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::EXCLUSIVE = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::FULLMUTEX = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::MAIN_DB = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::MAIN_JOURNAL = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::MASTER_JOURNAL = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::MEMORY = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::NOMUTEX = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::PRIVATECACHE = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::READONLY = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::READWRITE = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::SHAREDCACHE = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::SUBJOURNAL = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::TEMP_DB = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::TEMP_JOURNAL = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::TRANSIENT_DB = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::URI = T.let(T.unsafe(nil), Integer)
+SQLite3::Constants::Open::WAL = T.let(T.unsafe(nil), Integer)
+module SQLite3::Constants::TextRep; end
+
+# source://sqlite3//lib/sqlite3/constants.rb#8
+SQLite3::Constants::TextRep::ANY = T.let(T.unsafe(nil), Integer)
+
+# source://sqlite3//lib/sqlite3/constants.rb#9
+SQLite3::Constants::TextRep::DETERMINISTIC = T.let(T.unsafe(nil), Integer)
+
+# source://sqlite3//lib/sqlite3/constants.rb#7
+SQLite3::Constants::TextRep::UTF16 = T.let(T.unsafe(nil), Integer)
+
+# source://sqlite3//lib/sqlite3/constants.rb#6
+SQLite3::Constants::TextRep::UTF16BE = T.let(T.unsafe(nil), Integer)
+
+# source://sqlite3//lib/sqlite3/constants.rb#5
+SQLite3::Constants::TextRep::UTF16LE = T.let(T.unsafe(nil), Integer)
+
+# source://sqlite3//lib/sqlite3/constants.rb#4
+SQLite3::Constants::TextRep::UTF8 = T.let(T.unsafe(nil), Integer)
+
+class SQLite3::ConstraintException < ::SQLite3::Exception; end
+class SQLite3::CorruptException < ::SQLite3::Exception; end
+
+# The Database class encapsulates a single connection to a SQLite3 database.
+# Its usage is very straightforward:
+#
+#   require 'sqlite3'
+#
+#   SQLite3::Database.new( "data.db" ) do |db|
+#     db.execute( "select * from table" ) do |row|
+#       p row
+#     end
+#   end
+#
+# It wraps the lower-level methods provides by the selected driver, and
+# includes the Pragmas module for access to various pragma convenience
+# methods.
+#
+# The Database class provides type translation services as well, by which
+# the SQLite3 data types (which are all represented as strings) may be
+# converted into their corresponding types (as defined in the schemas
+# for their tables). This translation only occurs when querying data from
+# the database--insertions and updates are all still typeless.
+#
+# Furthermore, the Database class has been designed to work well with the
+# ArrayFields module from Ara Howard. If you require the ArrayFields
+# module before performing a query, and if you have not enabled results as
+# hashes, then the results will all be indexible by field name.
+class SQLite3::Database
+  include ::SQLite3::Pragmas
+
+  # call-seq: SQLite3::Database.new(file, options = {})
+  #
+  # Create a new Database object that opens the given file. If utf16
+  # is +true+, the filename is interpreted as a UTF-16 encoded string.
+  #
+  # By default, the new database will return result rows as arrays
+  # (#results_as_hash) and has type translation disabled (#type_translation=).
+  #
+  # @return [Database] a new instance of Database
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#65
+  def initialize(file, options = T.unsafe(nil), zvfs = T.unsafe(nil)); end
+
+  # Installs (or removes) a block that will be invoked for every access
+  # to the database. If the block returns 0 (or +nil+), the statement
+  # is allowed to proceed. Returning 1 causes an authorization error to
+  # occur, and returning 2 causes the access to be silently denied.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#142
+  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
+
+  # Returns the value of attribute collations.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#36
+  def collations; end
+
+  # Commits the current transaction. If there is no current transaction,
+  # this will cause an error to be raised. This returns +true+, in order
+  # to allow it to be used in idioms like
+  # <tt>abort? and rollback or commit</tt>.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#654
+  def commit; end
+
+  def complete?(_arg0); end
+
+  # Creates a new aggregate function for use in SQL statements. Aggregate
+  # functions are functions that apply over every row in the result set,
+  # instead of over just a single row. (A very common aggregate function
+  # is the "count" function, for determining the number of rows that match
+  # a query.)
+  #
+  # The new function will be added as +name+, with the given +arity+. (For
+  # variable arity functions, use -1 for the arity.)
+  #
+  # The +step+ parameter must be a proc object that accepts as its first
+  # parameter a FunctionProxy instance (representing the function
+  # invocation), with any subsequent parameters (up to the function's arity).
+  # The +step+ callback will be invoked once for each row of the result set.
+  #
+  # The +finalize+ parameter must be a +proc+ object that accepts only a
+  # single parameter, the FunctionProxy instance representing the current
+  # function invocation. It should invoke FunctionProxy#result= to
+  # store the result of the function.
+  #
+  # Example:
+  #
+  #   db.create_aggregate( "lengths", 1 ) do
+  #     step do |func, value|
+  #       func[ :total ] ||= 0
+  #       func[ :total ] += ( value ? value.length : 0 )
+  #     end
+  #
+  #     finalize do |func|
+  #       func.result = func[ :total ] || 0
+  #     end
+  #   end
+  #
+  #   puts db.get_first_value( "select lengths(name) from table" )
+  #
+  # See also #create_aggregate_handler for a more object-oriented approach to
+  # aggregate functions.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#445
+  def create_aggregate(name, arity, step = T.unsafe(nil), finalize = T.unsafe(nil), text_rep = T.unsafe(nil), &block); end
+
+  # This is another approach to creating an aggregate function (see
+  # #create_aggregate). Instead of explicitly specifying the name,
+  # callbacks, arity, and type, you specify a factory object
+  # (the "handler") that knows how to obtain all of that information. The
+  # handler should respond to the following messages:
+  #
+  # +arity+:: corresponds to the +arity+ parameter of #create_aggregate. This
+  #           message is optional, and if the handler does not respond to it,
+  #           the function will have an arity of -1.
+  # +name+:: this is the name of the function. The handler _must_ implement
+  #          this message.
+  # +new+:: this must be implemented by the handler. It should return a new
+  #         instance of the object that will handle a specific invocation of
+  #         the function.
+  #
+  # The handler instance (the object returned by the +new+ message, described
+  # above), must respond to the following messages:
+  #
+  # +step+:: this is the method that will be called for each step of the
+  #          aggregate function's evaluation. It should implement the same
+  #          signature as the +step+ callback for #create_aggregate.
+  # +finalize+:: this is the method that will be called to finalize the
+  #              aggregate function's evaluation. It should implement the
+  #              same signature as the +finalize+ callback for
+  #              #create_aggregate.
+  #
+  # Example:
+  #
+  #   class LengthsAggregateHandler
+  #     def self.arity; 1; end
+  #     def self.name; 'lengths'; end
+  #
+  #     def initialize
+  #       @total = 0
+  #     end
+  #
+  #     def step( ctx, name )
+  #       @total += ( name ? name.length : 0 )
+  #     end
+  #
+  #     def finalize( ctx )
+  #       ctx.result = @total
+  #     end
+  #   end
+  #
+  #   db.create_aggregate_handler( LengthsAggregateHandler )
+  #   puts db.get_first_value( "select lengths(name) from A" )
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#543
+  def create_aggregate_handler(handler); end
+
+  # Creates a new function for use in SQL statements. It will be added as
+  # +name+, with the given +arity+. (For variable arity functions, use
+  # -1 for the arity.)
+  #
+  # The block should accept at least one parameter--the FunctionProxy
+  # instance that wraps this function invocation--and any other
+  # arguments it needs (up to its arity).
+  #
+  # The block does not return a value directly. Instead, it will invoke
+  # the FunctionProxy#result= method on the +func+ parameter and
+  # indicate the return value that way.
+  #
+  # Example:
+  #
+  #   db.create_function( "maim", 1 ) do |func, value|
+  #     if value.nil?
+  #       func.result = nil
+  #     else
+  #       func.result = value.split(//).sort.join
+  #     end
+  #   end
+  #
+  #   puts db.get_first_value( "select maim(name) from table" )
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#400
+  def create_function(name, arity, text_rep = T.unsafe(nil), &block); end
+
+  # Define an aggregate function named +name+ using a object template
+  # object +aggregator+. +aggregator+ must respond to +step+ and +finalize+.
+  # +step+ will be called with row information and +finalize+ must return the
+  # return value for the aggregator function.
+  #
+  # _API Change:_ +aggregator+ must also implement +clone+. The provided
+  # +aggregator+ object will serve as template that is cloned to provide the
+  # individual instances of the aggregate function. Regular ruby objects
+  # already provide a suitable +clone+.
+  # The functions arity is the arity of the +step+ method.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#580
+  def define_aggregator(name, aggregator); 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
+
+  # Executes the given SQL statement. If additional parameters are given,
+  # they are treated as bind variables, and are bound to the placeholders in
+  # the query.
+  #
+  # Note that if any of the values passed to this are hashes, then the
+  # key/value pairs are each bound separately, with the key being used as
+  # the name of the placeholder to bind the value to.
+  #
+  # The block is optional. If given, it will be invoked for each row returned
+  # by the query. Otherwise, any results are accumulated into an array and
+  # returned wholesale.
+  #
+  # See also #execute2, #query, and #execute_batch for additional ways of
+  # executing statements.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#183
+  def execute(sql, bind_vars = T.unsafe(nil), *args, &block); end
+
+  # Executes the given SQL statement, exactly as with #execute. However, the
+  # first row returned (either via the block, or in the returned array) is
+  # always the names of the columns. Subsequent rows correspond to the data
+  # from the result set.
+  #
+  # Thus, even if the query itself returns no rows, this method will always
+  # return at least one row--the names of the columns.
+  #
+  # See also #execute, #query, and #execute_batch for additional ways of
+  # executing statements.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#222
+  def execute2(sql, *bind_vars); end
+
+  # Executes all SQL statements in the given string. By contrast, the other
+  # means of executing queries will only execute the first statement in the
+  # string, ignoring all subsequent statements. This will execute each one
+  # in turn. The same bind parameters, if given, will be applied to each
+  # statement.
+  #
+  # This always returns +nil+, making it unsuitable for queries that return
+  # rows.
+  #
+  # See also #execute_batch2 for additional ways of
+  # executing statements.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#246
+  def execute_batch(sql, bind_vars = T.unsafe(nil), *args); end
+
+  # Executes all SQL statements in the given string. By contrast, the other
+  # means of executing queries will only execute the first statement in the
+  # string, ignoring all subsequent statements. This will execute each one
+  # in turn. Bind parameters cannot be passed to #execute_batch2.
+  #
+  # If a query is made, all values will be returned as strings.
+  # If no query is made, an empty array will be returned.
+  #
+  # Because all values except for 'NULL' are returned as strings,
+  # a block can be passed to parse the values accordingly.
+  #
+  # See also #execute_batch for additional ways of
+  # executing statements.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#303
+  def execute_batch2(sql, &block); end
+
+  def extended_result_codes=(_arg0); end
+
+  # Returns the filename for the database named +db_name+.  +db_name+ defaults
+  # to "main".  Main return `nil` or an empty string if the database is
+  # temporary or in-memory.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#165
+  def filename(db_name = T.unsafe(nil)); end
+
+  # A convenience method for obtaining the first row of a result set, and
+  # discarding all others. It is otherwise identical to #execute.
+  #
+  # See also #get_first_value.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#357
+  def get_first_row(sql, *bind_vars); end
+
+  # A convenience method for obtaining the first value of the first row of a
+  # result set, and discarding all other values and rows. It is otherwise
+  # identical to #execute.
+  #
+  # See also #get_first_row.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#366
+  def get_first_value(sql, *bind_vars); end
+
+  def interrupt; end
+  def last_insert_row_id; end
+  def load_extension(_arg0); end
+
+  # Returns a Statement object representing the given SQL. This does not
+  # execute the statement; it merely prepares the statement for execution.
+  #
+  # The Statement can then be executed using Statement#execute.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#151
+  def prepare(sql); end
+
+  # This is a convenience method for creating a statement, binding
+  # parameters to it, and calling execute:
+  #
+  #   result = db.query( "select * from foo where a=?", [5])
+  #   # is the same as
+  #   result = db.prepare( "select * from foo where a=?" ).execute( 5 )
+  #
+  # You must be sure to call +close+ on the ResultSet instance that is
+  # returned, or you could have problems with locks on the table. If called
+  # with a block, +close+ will be invoked implicitly when the block
+  # terminates.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#325
+  def query(sql, bind_vars = T.unsafe(nil), *args); end
+
+  # Returns +true+ if the database has been open in readonly mode
+  # A helper to check before performing any operation
+  #
+  # @return [Boolean]
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#670
+  def readonly?; end
+
+  # A boolean that indicates whether rows in result sets should be returned
+  # as hashes or not. By default, rows are returned as arrays.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#55
+  def results_as_hash; end
+
+  # A boolean that indicates whether rows in result sets should be returned
+  # as hashes or not. By default, rows are returned as arrays.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#55
+  def results_as_hash=(_arg0); end
+
+  # Rolls the current transaction back. If there is no current transaction,
+  # this will cause an error to be raised. This returns +true+, in order
+  # to allow it to be used in idioms like
+  # <tt>abort? and rollback or commit</tt>.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#663
+  def rollback; end
+
+  def total_changes; end
+  def trace(*_arg0); end
+
+  # Begins a new transaction. Note that nested transactions are not allowed
+  # by SQLite, so attempting to nest a transaction will result in a runtime
+  # exception.
+  #
+  # The +mode+ parameter may be either <tt>:deferred</tt> (the default),
+  # <tt>:immediate</tt>, or <tt>:exclusive</tt>.
+  #
+  # If a block is given, the database instance is yielded to it, and the
+  # transaction is committed when the block terminates. If the block
+  # raises an exception, a rollback will be performed instead. Note that if
+  # a block is given, #commit and #rollback should never be called
+  # explicitly or you'll get an error when the block terminates.
+  #
+  # If a block is not given, it is the caller's responsibility to end the
+  # transaction explicitly, either by calling #commit, or by calling
+  # #rollback.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#632
+  def transaction(mode = T.unsafe(nil)); end
+
+  def transaction_active?; end
+
+  # Translates a +row+ of data from the database with the given +types+
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#721
+  def translate_from_db(types, row); end
+
+  # Return the type translator employed by this database instance. Each
+  # database instance has its own type translator; this allows for different
+  # type handlers to be installed in each instance without affecting other
+  # instances. Furthermore, the translators are instantiated lazily, so that
+  # if a database does not use type translation, it will not be burdened by
+  # the overhead of a useless type translator. (See the Translator class.)
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#134
+  def translator; end
+
+  # source://sqlite3//lib/sqlite3/database.rb#126
+  def type_translation; end
+
+  # source://sqlite3//lib/sqlite3/database.rb#117
+  def type_translation=(value); end
+
+  private
+
+  def db_filename(_arg0); end
+  def define_aggregator2(_arg0, _arg1); end
+  def disable_quirk_mode; end
+  def exec_batch(_arg0, _arg1); end
+
+  # source://sqlite3//lib/sqlite3/database.rb#729
+  def make_type_translator(should_translate); end
+
+  def open16(_arg0); end
+  def open_v2(_arg0, _arg1, _arg2); end
+
+  class << self
+    def open(*_arg0); end
+
+    # Quotes the given string, making it safe to use in an SQL statement.
+    # It replaces all instances of the single-quote character with two
+    # single-quote characters. The modified string is returned.
+    #
+    # source://sqlite3//lib/sqlite3/database.rb#47
+    def quote(string); end
+  end
+end
+
+# A helper class for dealing with custom functions (see #create_function,
+# #create_aggregate, and #create_aggregate_handler). It encapsulates the
+# opaque function object that represents the current invocation. It also
+# provides more convenient access to the API functions that operate on
+# the function object.
+#
+# This class will almost _always_ be instantiated indirectly, by working
+# with the create methods mentioned above.
+class SQLite3::Database::FunctionProxy
+  # Create a new FunctionProxy that encapsulates the given +func+ object.
+  # If context is non-nil, the functions context will be set to that. If
+  # it is non-nil, it must quack like a Hash. If it is nil, then none of
+  # the context functions will be available.
+  #
+  # @return [FunctionProxy] a new instance of FunctionProxy
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#689
+  def initialize; end
+
+  # Returns the value with the given key from the context. This is only
+  # available to aggregate functions.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#709
+  def [](key); end
+
+  # Sets the value with the given key in the context. This is only
+  # available to aggregate functions.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#715
+  def []=(key, value); end
+
+  # (Only available to aggregate functions.) Returns the number of rows
+  # that the aggregate has processed so far. This will include the current
+  # row, and so will always return at least 1.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#703
+  def count; end
+
+  # Returns the value of attribute result.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#683
+  def result; end
+
+  # Sets the attribute result
+  #
+  # @param value the value to set the attribute result to.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#683
+  def result=(_arg0); end
+
+  # Set the result of the function to the given error message.
+  # The function will then return that error.
+  #
+  # source://sqlite3//lib/sqlite3/database.rb#696
+  def set_error(error); end
+end
+
+# source://sqlite3//lib/sqlite3/database.rb#727
+SQLite3::Database::NULL_TRANSLATOR = T.let(T.unsafe(nil), Proc)
+
+class SQLite3::EmptyException < ::SQLite3::Exception; end
+
+class SQLite3::Exception < ::StandardError
+  # A convenience for accessing the error code for this exception.
+  #
+  # source://sqlite3//lib/sqlite3/errors.rb#6
+  def code; end
+end
+
+class SQLite3::FormatException < ::SQLite3::Exception; end
+class SQLite3::FullException < ::SQLite3::Exception; end
+class SQLite3::IOException < ::SQLite3::Exception; end
+class SQLite3::InternalException < ::SQLite3::Exception; end
+class SQLite3::InterruptException < ::SQLite3::Exception; end
+class SQLite3::LockedException < ::SQLite3::Exception; end
+class SQLite3::MemoryException < ::SQLite3::Exception; end
+class SQLite3::MismatchException < ::SQLite3::Exception; end
+class SQLite3::MisuseException < ::SQLite3::Exception; end
+class SQLite3::NotADatabaseException < ::SQLite3::Exception; end
+class SQLite3::NotFoundException < ::SQLite3::Exception; end
+class SQLite3::PermissionException < ::SQLite3::Exception; end
+
+# This module is intended for inclusion solely by the Database class. It
+# defines convenience methods for the various pragmas supported by SQLite3.
+#
+# For a detailed description of these pragmas, see the SQLite3 documentation
+# at http://sqlite.org/pragma.html.
+module SQLite3::Pragmas
+  # source://sqlite3//lib/sqlite3/pragmas.rb#104
+  def application_id; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#108
+  def application_id=(integer); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#112
+  def auto_vacuum; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#116
+  def auto_vacuum=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#120
+  def automatic_index; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#124
+  def automatic_index=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#128
+  def busy_timeout; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#132
+  def busy_timeout=(milliseconds); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#136
+  def cache_size; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#140
+  def cache_size=(size); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#144
+  def cache_spill; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#148
+  def cache_spill=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#152
+  def case_sensitive_like=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#156
+  def cell_size_check; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#160
+  def cell_size_check=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#164
+  def checkpoint_fullfsync; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#168
+  def checkpoint_fullfsync=(mode); end
+
+  # :yields: row
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#172
+  def collation_list(&block); end
+
+  # :yields: row
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#176
+  def compile_options(&block); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#180
+  def count_changes; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#184
+  def count_changes=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#188
+  def data_version; end
+
+  # :yields: row
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#192
+  def database_list(&block); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#196
+  def default_cache_size; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#200
+  def default_cache_size=(size); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#204
+  def default_synchronous; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#208
+  def default_synchronous=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#212
+  def default_temp_store; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#216
+  def default_temp_store=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#220
+  def defer_foreign_keys; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#224
+  def defer_foreign_keys=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#228
+  def encoding; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#232
+  def encoding=(mode); end
+
+  # :yields: row
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#236
+  def foreign_key_check(*table, &block); end
+
+  # :yields: row
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#240
+  def foreign_key_list(table, &block); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#244
+  def foreign_keys; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#248
+  def foreign_keys=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#252
+  def freelist_count; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#256
+  def full_column_names; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#260
+  def full_column_names=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#264
+  def fullfsync; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#268
+  def fullfsync=(mode); end
+
+  # Returns +true+ or +false+ depending on the value of the named pragma.
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#13
+  def get_boolean_pragma(name); end
+
+  # Return the value of the given pragma.
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#55
+  def get_enum_pragma(name); end
+
+  # Returns the value of the given pragma as an integer.
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#72
+  def get_int_pragma(name); end
+
+  # Requests the given pragma (and parameters), and if the block is given,
+  # each row of the result set will be yielded to it. Otherwise, the results
+  # are returned as an array.
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#45
+  def get_query_pragma(name, *params, &block); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#272
+  def ignore_check_constraints=(mode); end
+
+  # :yields: row
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#276
+  def incremental_vacuum(pages, &block); end
+
+  # :yields: row
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#280
+  def index_info(index, &block); end
+
+  # :yields: row
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#284
+  def index_list(table, &block); end
+
+  # :yields: row
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#288
+  def index_xinfo(index, &block); end
+
+  # :yields: row
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#292
+  def integrity_check(*num_errors, &block); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#296
+  def journal_mode; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#300
+  def journal_mode=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#304
+  def journal_size_limit; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#308
+  def journal_size_limit=(size); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#312
+  def legacy_file_format; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#316
+  def legacy_file_format=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#320
+  def locking_mode; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#324
+  def locking_mode=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#328
+  def max_page_count; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#332
+  def max_page_count=(size); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#336
+  def mmap_size; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#340
+  def mmap_size=(size); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#344
+  def page_count; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#348
+  def page_size; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#352
+  def page_size=(size); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#356
+  def parser_trace=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#360
+  def query_only; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#364
+  def query_only=(mode); end
+
+  # :yields: row
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#368
+  def quick_check(*num_errors, &block); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#372
+  def read_uncommitted; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#376
+  def read_uncommitted=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#380
+  def recursive_triggers; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#384
+  def recursive_triggers=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#388
+  def reverse_unordered_selects; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#392
+  def reverse_unordered_selects=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#396
+  def schema_cookie; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#400
+  def schema_cookie=(cookie); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#404
+  def schema_version; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#408
+  def schema_version=(version); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#412
+  def secure_delete; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#416
+  def secure_delete=(mode); end
+
+  # Sets the given pragma to the given boolean value. The value itself
+  # may be +true+ or +false+, or any other commonly used string or
+  # integer that represents truth.
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#20
+  def set_boolean_pragma(name, mode); end
+
+  # Set the value of the given pragma to +mode+. The +mode+ parameter must
+  # conform to one of the values in the given +enum+ array. Each entry in
+  # the array is another array comprised of elements in the enumeration that
+  # have duplicate values. See #synchronous, #default_synchronous,
+  # #temp_store, and #default_temp_store for usage examples.
+  #
+  # @raise [Exception]
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#64
+  def set_enum_pragma(name, mode, enums); end
+
+  # Set the value of the given pragma to the integer value of the +value+
+  # parameter.
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#78
+  def set_int_pragma(name, value); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#420
+  def short_column_names; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#424
+  def short_column_names=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#428
+  def shrink_memory; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#432
+  def soft_heap_limit; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#436
+  def soft_heap_limit=(mode); end
+
+  # :yields: row
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#440
+  def stats(&block); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#444
+  def synchronous; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#448
+  def synchronous=(mode); end
+
+  # Returns information about +table+.  Yields each row of table information
+  # if a block is provided.
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#527
+  def table_info(table); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#452
+  def temp_store; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#456
+  def temp_store=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#460
+  def threads; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#464
+  def threads=(count); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#468
+  def user_cookie; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#472
+  def user_cookie=(cookie); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#476
+  def user_version; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#480
+  def user_version=(version); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#484
+  def vdbe_addoptrace=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#488
+  def vdbe_debug=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#492
+  def vdbe_listing=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#496
+  def vdbe_trace; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#500
+  def vdbe_trace=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#504
+  def wal_autocheckpoint; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#508
+  def wal_autocheckpoint=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#512
+  def wal_checkpoint; end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#516
+  def wal_checkpoint=(mode); end
+
+  # source://sqlite3//lib/sqlite3/pragmas.rb#520
+  def writable_schema=(mode); end
+
+  private
+
+  # Since SQLite 3.3.8, the table_info pragma has returned the default
+  # value of the row as a quoted SQL value. This method essentially
+  # unquotes those values.
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#583
+  def tweak_default(hash); end
+
+  # Compares two version strings
+  #
+  # source://sqlite3//lib/sqlite3/pragmas.rb#567
+  def version_compare(v1, v2); end
+end
+
+# The enumeration of valid auto vacuum modes.
+#
+# source://sqlite3//lib/sqlite3/pragmas.rb#89
+SQLite3::Pragmas::AUTO_VACUUM_MODES = T.let(T.unsafe(nil), Array)
+
+# The list of valid encodings.
+#
+# source://sqlite3//lib/sqlite3/pragmas.rb#99
+SQLite3::Pragmas::ENCODINGS = T.let(T.unsafe(nil), Array)
+
+# The list of valid journaling modes.
+#
+# source://sqlite3//lib/sqlite3/pragmas.rb#92
+SQLite3::Pragmas::JOURNAL_MODES = T.let(T.unsafe(nil), Array)
+
+# The list of valid locking modes.
+#
+# source://sqlite3//lib/sqlite3/pragmas.rb#96
+SQLite3::Pragmas::LOCKING_MODES = T.let(T.unsafe(nil), Array)
+
+# The enumeration of valid synchronous modes.
+#
+# source://sqlite3//lib/sqlite3/pragmas.rb#83
+SQLite3::Pragmas::SYNCHRONOUS_MODES = T.let(T.unsafe(nil), Array)
+
+# The enumeration of valid temp store modes.
+#
+# source://sqlite3//lib/sqlite3/pragmas.rb#86
+SQLite3::Pragmas::TEMP_STORE_MODES = T.let(T.unsafe(nil), Array)
+
+# The list of valid WAL checkpoints.
+#
+# source://sqlite3//lib/sqlite3/pragmas.rb#102
+SQLite3::Pragmas::WAL_CHECKPOINTS = T.let(T.unsafe(nil), Array)
+
+class SQLite3::ProtocolException < ::SQLite3::Exception; end
+class SQLite3::RangeException < ::SQLite3::Exception; end
+class SQLite3::ReadOnlyException < ::SQLite3::Exception; end
+
+# The ResultSet object encapsulates the enumerability of a query's output.
+# It is a simple cursor over the data that the query returns. It will
+# very rarely (if ever) be instantiated directly. Instead, clients should
+# obtain a ResultSet instance via Statement#execute.
+class SQLite3::ResultSet
+  include ::Enumerable
+
+  # Create a new ResultSet attached to the given database, using the
+  # given sql text.
+  #
+  # @return [ResultSet] a new instance of ResultSet
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#72
+  def initialize(db, stmt); end
+
+  # Closes the statement that spawned this result set.
+  # <em>Use with caution!</em> Closing a result set will automatically
+  # close any other result sets that were spawned from the same statement.
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#149
+  def close; end
+
+  # Queries whether the underlying statement has been closed or not.
+  #
+  # @return [Boolean]
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#154
+  def closed?; end
+
+  # Returns the names of the columns returned by this result set.
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#164
+  def columns; end
+
+  # Required by the Enumerable mixin. Provides an internal iterator over the
+  # rows of the result set.
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#132
+  def each; end
+
+  # Provides an internal iterator over the rows of the result set where
+  # each row is yielded as a hash.
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#140
+  def each_hash; end
+
+  # Query whether the cursor has reached the end of the result set or not.
+  #
+  # @return [Boolean]
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#86
+  def eof?; end
+
+  # Obtain the next row from the cursor. If there are no more rows to be
+  # had, this will return +nil+. If type translation is active on the
+  # corresponding database, the values in the row will be translated
+  # according to their types.
+  #
+  # The returned value will be an array, unless Database#results_as_hash has
+  # been set to +true+, in which case the returned value will be a hash.
+  #
+  # For arrays, the column names are accessible via the +fields+ property,
+  # and the column types are accessible via the +types+ property.
+  #
+  # For hashes, the column names are the keys of the hash, and the column
+  # types are accessible via the +types+ property.
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#103
+  def next; end
+
+  # Return the next row as a hash
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#169
+  def next_hash; end
+
+  # Reset the cursor, so that a result set which has reached end-of-file
+  # can be rewound and reiterated.
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#79
+  def reset(*bind_params); end
+
+  # Returns the types of the columns returned by this result set.
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#159
+  def types; end
+end
+
+class SQLite3::ResultSet::ArrayWithTypes < ::Array
+  # Returns the value of attribute types.
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#14
+  def types; end
+
+  # Sets the attribute types
+  #
+  # @param value the value to set the attribute types to.
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#14
+  def types=(_arg0); end
+end
+
+class SQLite3::ResultSet::ArrayWithTypesAndFields < ::Array
+  # source://sqlite3//lib/sqlite3/resultset.rb#30
+  def fields; end
+
+  # Sets the attribute fields
+  #
+  # @param value the value to set the attribute fields to.
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#19
+  def fields=(_arg0); end
+
+  # source://sqlite3//lib/sqlite3/resultset.rb#21
+  def types; end
+
+  # Sets the attribute types
+  #
+  # @param value the value to set the attribute types to.
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#18
+  def types=(_arg0); end
+end
+
+# The class of which we return an object in case we want a Hash as
+# result.
+class SQLite3::ResultSet::HashWithTypesAndFields < ::Hash
+  # source://sqlite3//lib/sqlite3/resultset.rb#64
+  def [](key); end
+
+  # source://sqlite3//lib/sqlite3/resultset.rb#55
+  def fields; end
+
+  # Sets the attribute fields
+  #
+  # @param value the value to set the attribute fields to.
+  #
+  # source://sqlite3//lib/sqlite3/resultset.rb#44
+  def fields=(_arg0); end
+
+  # source://sqlite3//lib/sqlite3/resultset.rb#46
+  def types; end
+
+  # source://sqlite3//lib/sqlite3/resultset.rb#43
+  def types=(_arg0); end
+end
+
+class SQLite3::SQLException < ::SQLite3::Exception; end
+SQLite3::SQLITE_LOADED_VERSION = T.let(T.unsafe(nil), String)
+SQLite3::SQLITE_VERSION = T.let(T.unsafe(nil), String)
+SQLite3::SQLITE_VERSION_NUMBER = T.let(T.unsafe(nil), Integer)
+class SQLite3::SchemaChangedException < ::SQLite3::Exception; end
+
+# A statement represents a prepared-but-unexecuted SQL query. It will rarely
+# (if ever) be instantiated directly by a client, and is most often obtained
+# via the Database#prepare method.
+class SQLite3::Statement
+  include ::Enumerable
+
+  def initialize(_arg0, _arg1); end
+
+  # Returns true if the statement is currently active, meaning it has an
+  # open result set.
+  #
+  # @return [Boolean]
+  #
+  # source://sqlite3//lib/sqlite3/statement.rb#94
+  def active?; end
+
+  def bind_param(_arg0, _arg1); end
+  def bind_parameter_count; end
+
+  # Binds the given variables to the corresponding placeholders in the SQL
+  # text.
+  #
+  # See Database#execute for a description of the valid placeholder
+  # syntaxes.
+  #
+  # Example:
+  #
+  #   stmt = db.prepare( "select * from table where a=? and b=?" )
+  #   stmt.bind_params( 15, "hello" )
+  #
+  # See also #execute, #bind_param, Statement#bind_param, and
+  # Statement#bind_params.
+  #
+  # source://sqlite3//lib/sqlite3/statement.rb#35
+  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
+
+  # Return an array of the column names for this statement. Note that this
+  # may execute the statement in order to obtain the metadata; this makes it
+  # a (potentially) expensive operation.
+  #
+  # source://sqlite3//lib/sqlite3/statement.rb#101
+  def columns; end
+
+  def done?; end
+
+  # source://sqlite3//lib/sqlite3/statement.rb#106
+  def each; end
+
+  # Execute the statement. This creates a new ResultSet object for the
+  # statement's virtual machine. If a block was given, the new ResultSet will
+  # be yielded to it; otherwise, the ResultSet will be returned.
+  #
+  # Any parameters will be bound to the statement using #bind_params.
+  #
+  # Example:
+  #
+  #   stmt = db.prepare( "select * from table" )
+  #   stmt.execute do |result|
+  #     ...
+  #   end
+  #
+  # See also #bind_params, #execute!.
+  #
+  # @yield [@results]
+  #
+  # source://sqlite3//lib/sqlite3/statement.rb#61
+  def execute(*bind_vars); end
+
+  # Execute the statement. If no block was given, this returns an array of
+  # rows returned by executing the statement. Otherwise, each row will be
+  # yielded to the block.
+  #
+  # Any parameters will be bound to the statement using #bind_params.
+  #
+  # Example:
+  #
+  #   stmt = db.prepare( "select * from table" )
+  #   stmt.execute! do |row|
+  #     ...
+  #   end
+  #
+  # See also #bind_params, #execute.
+  #
+  # source://sqlite3//lib/sqlite3/statement.rb#87
+  def execute!(*bind_vars, &block); end
+
+  # Performs a sanity check to ensure that the statement is not
+  # closed. If it is, an exception is raised.
+  #
+  # source://sqlite3//lib/sqlite3/statement.rb#125
+  def must_be_open!; end
+
+  # This is any text that followed the first valid SQL statement in the text
+  # with which the statement was initialized. If there was no trailing text,
+  # this will be the empty string.
+  #
+  # source://sqlite3//lib/sqlite3/statement.rb#20
+  def remainder; end
+
+  def reset!; end
+  def step; end
+
+  # Return an array of the data types for each column in this statement. Note
+  # that this may execute the statement in order to obtain the metadata; this
+  # makes it a (potentially) expensive operation.
+  #
+  # source://sqlite3//lib/sqlite3/statement.rb#117
+  def types; end
+
+  private
+
+  # A convenience method for obtaining the metadata about the query. Note
+  # that this will actually execute the SQL, which means it can be a
+  # (potentially) expensive operation.
+  #
+  # source://sqlite3//lib/sqlite3/statement.rb#135
+  def get_metadata; end
+end
+
+class SQLite3::TooBigException < ::SQLite3::Exception; end
+
+# The Translator class encapsulates the logic and callbacks necessary for
+# converting string data to a value of some specified type. Every Database
+# instance may have a Translator instance, in order to assist in type
+# translation (Database#type_translation).
+#
+# Further, applications may define their own custom type translation logic
+# by registering translator blocks with the corresponding database's
+# translator instance (Database#translator).
+class SQLite3::Translator
+  # Create a new Translator instance. It will be preinitialized with default
+  # translators for most SQL data types.
+  #
+  # @return [Translator] a new instance of Translator
+  #
+  # source://sqlite3//lib/sqlite3/translator.rb#18
+  def initialize; end
+
+  # Add a new translator block, which will be invoked to process type
+  # translations to the given type. The type should be an SQL datatype, and
+  # may include parentheses (i.e., "VARCHAR(30)"). However, any parenthetical
+  # information is stripped off and discarded, so type translation decisions
+  # are made solely on the "base" type name.
+  #
+  # The translator block itself should accept two parameters, "type" and
+  # "value". In this case, the "type" is the full type name (including
+  # parentheses), so the block itself may include logic for changing how a
+  # type is translated based on the additional data. The "value" parameter
+  # is the (string) data to convert.
+  #
+  # The block should return the translated value.
+  #
+  # source://sqlite3//lib/sqlite3/translator.rb#37
+  def add_translator(type, &block); end
+
+  # Translate the given string value to a value of the given type. In the
+  # absence of an installed translator block for the given type, the value
+  # itself is always returned. Further, +nil+ values are never translated,
+  # and are always passed straight through regardless of the type parameter.
+  #
+  # source://sqlite3//lib/sqlite3/translator.rb#49
+  def translate(type, value); end
+
+  private
+
+  # Register the default translators for the current Translator instance.
+  # This includes translators for most major SQL data types.
+  #
+  # source://sqlite3//lib/sqlite3/translator.rb#73
+  def register_default_translators; end
+
+  # A convenience method for working with type names. This returns the "base"
+  # type name, without any parenthetical data.
+  #
+  # source://sqlite3//lib/sqlite3/translator.rb#62
+  def type_name(type); end
+end
+
+class SQLite3::UnsupportedException < ::SQLite3::Exception; end
+
+# source://sqlite3//lib/sqlite3/version.rb#3
+SQLite3::VERSION = T.let(T.unsafe(nil), String)
+
+class SQLite3::Value
+  # @return [Value] a new instance of Value
+  #
+  # source://sqlite3//lib/sqlite3/value.rb#8
+  def initialize(db, handle); end
+
+  # Returns the value of attribute handle.
+  #
+  # source://sqlite3//lib/sqlite3/value.rb#6
+  def handle; end
+
+  # source://sqlite3//lib/sqlite3/value.rb#21
+  def length(utf16 = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://sqlite3//lib/sqlite3/value.rb#13
+  def null?; end
+
+  # source://sqlite3//lib/sqlite3/value.rb#17
+  def to_blob; end
+
+  # source://sqlite3//lib/sqlite3/value.rb#29
+  def to_f; end
+
+  # source://sqlite3//lib/sqlite3/value.rb#33
+  def to_i; end
+
+  # source://sqlite3//lib/sqlite3/value.rb#37
+  def to_int64; end
+
+  # source://sqlite3//lib/sqlite3/value.rb#41
+  def to_s(utf16 = T.unsafe(nil)); end
+
+  # source://sqlite3//lib/sqlite3/value.rb#45
+  def type; end
+end
+
+module SQLite3::VersionProxy; end
+
+# source://sqlite3//lib/sqlite3/version.rb#9
+SQLite3::VersionProxy::BUILD = T.let(T.unsafe(nil), T.untyped)
+
+# source://sqlite3//lib/sqlite3/version.rb#6
+SQLite3::VersionProxy::MAJOR = T.let(T.unsafe(nil), Integer)
+
+# source://sqlite3//lib/sqlite3/version.rb#7
+SQLite3::VersionProxy::MINOR = T.let(T.unsafe(nil), Integer)
+
+# source://sqlite3//lib/sqlite3/version.rb#11
+SQLite3::VersionProxy::STRING = T.let(T.unsafe(nil), String)
+
+# source://sqlite3//lib/sqlite3/version.rb#8
+SQLite3::VersionProxy::TINY = T.let(T.unsafe(nil), Integer)
+
+# source://sqlite3//lib/sqlite3/version.rb#13
+SQLite3::VersionProxy::VERSION = T.let(T.unsafe(nil), String)
+
+class String
+  include ::Comparable
+
+  # source://sqlite3//lib/sqlite3/statement.rb#5
+  def to_blob; end
+end