# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT


class Blob(object):

  def close(self):
    """ Close the blob. """
    pass

  def read(self, length=-1):
    """ Read data at the current offset position.
    
      length
        Read length in bytes.
    
    If the end of the blob is reached, the data up to end of file will be returned.
    When length is not specified, or is negative, Blob.read() will read until the
    end of the blob. """
    pass

  def seek(self, offset, origin=0):
    """ Set the current access position to offset.
    
    The origin argument defaults to os.SEEK_SET (absolute blob positioning).
    Other values for origin are os.SEEK_CUR (seek relative to the current position)
    and os.SEEK_END (seek relative to the blob's end). """
    pass

  def tell(self):
    """ Return the current access position for the blob. """
    pass

  def write(self, data):
    """ Write data at the current offset.
    
    This function cannot change the blob length.  Writing beyond the end of the
    blob will result in an exception being raised. """
    pass

class Connection(object):
  """ SQLite database connection object. """

  DataError = None
  DatabaseError = None
  Error = None
  IntegrityError = None
  InterfaceError = None
  InternalError = None
  NotSupportedError = None
  OperationalError = None
  ProgrammingError = None
  Warning = None

  def __init__(self, *args, **kwargs):
    pass

  autocommit = property(None, None, None,
                        )


  def backup(self, target, pages=-1, progress=None, name='main', sleep=0.25):
    """ Makes a backup of the database. """
    pass

  def blobopen(self, table, column, row, readonly=False, name='main'):
    """ Open and return a BLOB object.
    
      table
        Table name.
      column
        Column name.
      row
        Row index.
      readonly
        Open the BLOB without write permissions.
      name
        Database name. """
    pass

  def close(self):
    """ Close the database connection.
    
    Any pending transaction is not committed implicitly. """
    pass

  def commit(self):
    """ Commit any pending transaction to the database.
    
    If there is no open transaction, this method is a no-op. """
    pass

  def create_aggregate(self, name, n_arg, aggregate_class):
    """ Creates a new aggregate. """
    pass

  def create_collation(self, name, callback):
    """ Creates a collation function. """
    pass

  def create_function(self, name, narg, func, deterministic=False):
    """ Creates a new function. """
    pass

  def create_window_function(self, name, num_params, aggregate_class):
    """ Creates or redefines an aggregate window function. Non-standard.
    
      name
        The name of the SQL aggregate window function to be created or
        redefined.
      num_params
        The number of arguments the step and inverse methods takes.
      aggregate_class
        A class with step(), finalize(), value(), and inverse() methods.
        Set to None to clear the window function. """
    pass

  def cursor(self):
    """ Return a cursor for the connection. """
    pass

  def execute(self):
    """ Executes an SQL statement. """
    pass

  def executemany(self, sql, parameters):
    """ Repeatedly executes an SQL statement. """
    pass

  def executescript(self, sql_script):
    """ Executes multiple SQL statements at once. """
    pass

  def getconfig(self, op):
    """ Query a boolean connection configuration option.
    
      op
        The configuration verb; one of the sqlite3.SQLITE_DBCONFIG codes. """
    pass

  def getlimit(self, category):
    """ Get connection run-time limits.
    
      category
        The limit category to be queried. """
    pass

  in_transaction = property(None, None, None,
                            )


  def interrupt(self):
    """ Abort any pending database operation. """
    pass

  isolation_level = property(None, None, None,
                             )


  def iterdump(self):
    """ Returns iterator to the dump of the database in an SQL text format. """
    pass

  def rollback(self):
    """ Roll back to the start of any pending transaction.
    
    If there is no open transaction, this method is a no-op. """
    pass

  row_factory = None

  def set_authorizer(self, authorizer_callback):
    """ Sets authorizer callback. """
    pass

  def set_progress_handler(self, progress_handler, n):
    """ Sets progress handler callback. """
    pass

  def set_trace_callback(self, trace_callback):
    """ Sets a trace callback called for each SQL statement (passed as unicode). """
    pass

  def setconfig(self, op, enable=True):
    """ Set a boolean connection configuration option.
    
      op
        The configuration verb; one of the sqlite3.SQLITE_DBCONFIG codes. """
    pass

  def setlimit(self, category, limit):
    """ Set connection run-time limits.
    
      category
        The limit category to be set.
      limit
        The new limit. If the new limit is a negative number, the limit is
        unchanged.
    
    Attempts to increase a limit above its hard upper bound are silently truncated
    to the hard upper bound. Regardless of whether or not the limit was changed,
    the prior value of the limit is returned. """
    pass

  text_factory = None
  total_changes = property(None, None, None,
                           )


class Cursor(object):
  """ SQLite database cursor class. """

  def __init__(self, *args, **kwargs):
    pass

  arraysize = None

  def close(self):
    """ Closes the cursor. """
    pass

  connection = None
  description = None

  def execute(self, sql, parameters=()):
    """ Executes an SQL statement. """
    pass

  def executemany(self, sql, seq_of_parameters):
    """ Repeatedly executes an SQL statement. """
    pass

  def executescript(self, sql_script):
    """ Executes multiple SQL statements at once. """
    pass

  def fetchall(self):
    """ Fetches all rows from the resultset. """
    pass

  def fetchmany(self, size=1):
    """ Fetches several rows from the resultset.
    
      size
        The default value is set by the Cursor.arraysize attribute. """
    pass

  def fetchone(self):
    """ Fetches one row from the resultset. """
    pass

  lastrowid = None
  row_factory = None
  rowcount = None

  def setinputsizes(self, sizes):
    """ Required by DB-API. Does nothing in sqlite3. """
    pass

  def setoutputsize(self, size, column=None):
    """ Required by DB-API. Does nothing in sqlite3. """
    pass

class DataError(DatabaseError):

  pass

class DatabaseError(Error):

  pass

class Error(Exception):

  pass

class IntegrityError(DatabaseError):

  pass

class InterfaceError(Error):

  pass

class InternalError(DatabaseError):

  pass

LEGACY_TRANSACTION_CONTROL = -1

class NotSupportedError(DatabaseError):

  pass

class OperationalError(DatabaseError):

  pass

PARSE_COLNAMES = 2
PARSE_DECLTYPES = 1

class PrepareProtocol(object):
  """ PEP 246 style object adaption protocol type. """

  def __init__(self, *args, **kwargs):
    pass

class ProgrammingError(DatabaseError):

  pass

class Row(object):

  def keys(self):
    """ Returns the keys of the row. """
    pass

SQLITE_ABORT = 4
SQLITE_ABORT_ROLLBACK = 516
SQLITE_ALTER_TABLE = 26
SQLITE_ANALYZE = 28
SQLITE_ATTACH = 24
SQLITE_AUTH = 23
SQLITE_AUTH_USER = 279
SQLITE_BUSY = 5
SQLITE_BUSY_RECOVERY = 261
SQLITE_BUSY_SNAPSHOT = 517
SQLITE_CANTOPEN = 14
SQLITE_CANTOPEN_CONVPATH = 1038
SQLITE_CANTOPEN_DIRTYWAL = 1294
SQLITE_CANTOPEN_FULLPATH = 782
SQLITE_CANTOPEN_ISDIR = 526
SQLITE_CANTOPEN_NOTEMPDIR = 270
SQLITE_CONSTRAINT = 19
SQLITE_CONSTRAINT_CHECK = 275
SQLITE_CONSTRAINT_COMMITHOOK = 531
SQLITE_CONSTRAINT_FOREIGNKEY = 787
SQLITE_CONSTRAINT_FUNCTION = 1043
SQLITE_CONSTRAINT_NOTNULL = 1299
SQLITE_CONSTRAINT_PRIMARYKEY = 1555
SQLITE_CONSTRAINT_ROWID = 2579
SQLITE_CONSTRAINT_TRIGGER = 1811
SQLITE_CONSTRAINT_UNIQUE = 2067
SQLITE_CONSTRAINT_VTAB = 2323
SQLITE_CORRUPT = 11
SQLITE_CORRUPT_SEQUENCE = 523
SQLITE_CORRUPT_VTAB = 267
SQLITE_CREATE_INDEX = 1
SQLITE_CREATE_TABLE = 2
SQLITE_CREATE_TEMP_INDEX = 3
SQLITE_CREATE_TEMP_TABLE = 4
SQLITE_CREATE_TEMP_TRIGGER = 5
SQLITE_CREATE_TEMP_VIEW = 6
SQLITE_CREATE_TRIGGER = 7
SQLITE_CREATE_VIEW = 8
SQLITE_CREATE_VTABLE = 29
SQLITE_DBCONFIG_DEFENSIVE = 1010
SQLITE_DBCONFIG_ENABLE_FKEY = 1002
SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER = 1004
SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION = 1005
SQLITE_DBCONFIG_ENABLE_QPSG = 1007
SQLITE_DBCONFIG_ENABLE_TRIGGER = 1003
SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE = 1006
SQLITE_DBCONFIG_RESET_DATABASE = 1009
SQLITE_DBCONFIG_TRIGGER_EQP = 1008
SQLITE_DELETE = 9
SQLITE_DENY = 1
SQLITE_DETACH = 25
SQLITE_DONE = 101
SQLITE_DROP_INDEX = 10
SQLITE_DROP_TABLE = 11
SQLITE_DROP_TEMP_INDEX = 12
SQLITE_DROP_TEMP_TABLE = 13
SQLITE_DROP_TEMP_TRIGGER = 14
SQLITE_DROP_TEMP_VIEW = 15
SQLITE_DROP_TRIGGER = 16
SQLITE_DROP_VIEW = 17
SQLITE_DROP_VTABLE = 30
SQLITE_EMPTY = 16
SQLITE_ERROR = 1
SQLITE_ERROR_MISSING_COLLSEQ = 257
SQLITE_ERROR_RETRY = 513
SQLITE_ERROR_SNAPSHOT = 769
SQLITE_FORMAT = 24
SQLITE_FULL = 13
SQLITE_FUNCTION = 31
SQLITE_IGNORE = 2
SQLITE_INSERT = 18
SQLITE_INTERNAL = 2
SQLITE_INTERRUPT = 9
SQLITE_IOERR = 10
SQLITE_IOERR_ACCESS = 3338
SQLITE_IOERR_AUTH = 7178
SQLITE_IOERR_BEGIN_ATOMIC = 7434
SQLITE_IOERR_BLOCKED = 2826
SQLITE_IOERR_CHECKRESERVEDLOCK = 3594
SQLITE_IOERR_CLOSE = 4106
SQLITE_IOERR_COMMIT_ATOMIC = 7690
SQLITE_IOERR_CONVPATH = 6666
SQLITE_IOERR_DELETE = 2570
SQLITE_IOERR_DELETE_NOENT = 5898
SQLITE_IOERR_DIR_CLOSE = 4362
SQLITE_IOERR_DIR_FSYNC = 1290
SQLITE_IOERR_FSTAT = 1802
SQLITE_IOERR_FSYNC = 1034
SQLITE_IOERR_GETTEMPPATH = 6410
SQLITE_IOERR_LOCK = 3850
SQLITE_IOERR_MMAP = 6154
SQLITE_IOERR_NOMEM = 3082
SQLITE_IOERR_RDLOCK = 2314
SQLITE_IOERR_READ = 266
SQLITE_IOERR_ROLLBACK_ATOMIC = 7946
SQLITE_IOERR_SEEK = 5642
SQLITE_IOERR_SHMLOCK = 5130
SQLITE_IOERR_SHMMAP = 5386
SQLITE_IOERR_SHMOPEN = 4618
SQLITE_IOERR_SHMSIZE = 4874
SQLITE_IOERR_SHORT_READ = 522
SQLITE_IOERR_TRUNCATE = 1546
SQLITE_IOERR_UNLOCK = 2058
SQLITE_IOERR_VNODE = 6922
SQLITE_IOERR_WRITE = 778
SQLITE_LIMIT_ATTACHED = 7
SQLITE_LIMIT_COLUMN = 2
SQLITE_LIMIT_COMPOUND_SELECT = 4
SQLITE_LIMIT_EXPR_DEPTH = 3
SQLITE_LIMIT_FUNCTION_ARG = 6
SQLITE_LIMIT_LENGTH = 0
SQLITE_LIMIT_LIKE_PATTERN_LENGTH = 8
SQLITE_LIMIT_SQL_LENGTH = 1
SQLITE_LIMIT_TRIGGER_DEPTH = 10
SQLITE_LIMIT_VARIABLE_NUMBER = 9
SQLITE_LIMIT_VDBE_OP = 5
SQLITE_LIMIT_WORKER_THREADS = 11
SQLITE_LOCKED = 6
SQLITE_LOCKED_SHAREDCACHE = 262
SQLITE_LOCKED_VTAB = 518
SQLITE_MISMATCH = 20
SQLITE_MISUSE = 21
SQLITE_NOLFS = 22
SQLITE_NOMEM = 7
SQLITE_NOTADB = 26
SQLITE_NOTFOUND = 12
SQLITE_NOTICE = 27
SQLITE_NOTICE_RECOVER_ROLLBACK = 539
SQLITE_NOTICE_RECOVER_WAL = 283
SQLITE_OK = 0
SQLITE_OK_LOAD_PERMANENTLY = 256
SQLITE_PERM = 3
SQLITE_PRAGMA = 19
SQLITE_PROTOCOL = 15
SQLITE_RANGE = 25
SQLITE_READ = 20
SQLITE_READONLY = 8
SQLITE_READONLY_CANTINIT = 1288
SQLITE_READONLY_CANTLOCK = 520
SQLITE_READONLY_DBMOVED = 1032
SQLITE_READONLY_DIRECTORY = 1544
SQLITE_READONLY_RECOVERY = 264
SQLITE_READONLY_ROLLBACK = 776
SQLITE_RECURSIVE = 33
SQLITE_REINDEX = 27
SQLITE_ROW = 100
SQLITE_SAVEPOINT = 32
SQLITE_SCHEMA = 17
SQLITE_SELECT = 21
SQLITE_TOOBIG = 18
SQLITE_TRANSACTION = 22
SQLITE_UPDATE = 23
SQLITE_WARNING = 28
SQLITE_WARNING_AUTOINDEX = 284

class Warning(Exception):

  pass

__doc__ = None
__file__ = '/home/shared/src/ide/build-files/build-temp/runtimes-release/__os__/linux-arm64/runtime-python3.12/lib/python3.12/lib-dynload/_sqlite3.cpython-312-aarch64-linux-gnu.so'
__loader__ = None
__name__ = '_sqlite3'
__package__ = ''
__spec__ = None
_deprecated_version = '2.6.0'

def adapt():
  """ Adapt given object to given protocol. """
  pass

adapters = {}

def complete_statement(statement):
  """ Checks if a string contains a complete SQL statement. """
  pass

def connect():
  """ Opens a connection to the SQLite database file database.
  
  You can use ":memory:" to open a database connection to a database that resides
  in RAM instead of on disk. """
  pass

converters = {}

def enable_callback_tracebacks(enable):
  """ Enable or disable callback functions throwing errors to stderr. """
  pass

def register_adapter(type, adapter):
  """ Register a function to adapt Python objects to SQLite values. """
  pass

def register_converter(typename, converter):
  """ Register a function to convert SQLite values to Python objects. """
  pass

sqlite_version = '3.26.0'
threadsafety = 3