// CodeGear C++Builder
// Copyright (c) 1995, 2020 by Embarcadero Technologies, Inc.
// All rights reserved

// (DO NOT EDIT: machine generated header) 'DISQLite3Api.pas' rev: 34.00 (Windows)

#ifndef Disqlite3apiHPP
#define Disqlite3apiHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member 
#pragma pack(push,8)
#include <System.hpp>
#include <SysInit.hpp>
#include <DISystemCompat.hpp>
#include <Winapi.Windows.hpp>
#include <System.SysUtils.hpp>
#include <System.Math.hpp>

//-- user supplied -----------------------------------------------------------
#undef _F_RDWR
#undef _F_READ
#undef _F_WRIT
#undef _F_BUF
#undef _F_LBUF
#undef _F_ERR
#undef _F_EOF
#undef _F_BIN
#undef _F_IN
#undef _F_OUT
#undef _F_TERM
#undef SEEK_CUR
#undef SEEK_END
#undef SEEK_SET

namespace Disqlite3api
{
//-- forward type declarations -----------------------------------------------
struct DECLSPEC_DRECORD sqlite3
{
};


struct sqlite3_file;
struct sqlite3_io_methods;
struct DECLSPEC_DRECORD sqlite3_mutex
{
};


struct sqlite3_vfs;
struct sqlite3_mem_methods;
struct DECLSPEC_DRECORD sqlite3_stmt
{
};


struct DECLSPEC_DRECORD sqlite3_value
{
};


struct DECLSPEC_DRECORD sqlite3_context
{
};


struct sqlite3_module;
struct sqlite3_vtab;
struct sqlite3_vtab_cursor;
struct sqlite3_index_constraint;
struct sqlite3_index_orderby;
struct sqlite3_index_constraint_usage;
struct sqlite3_index_info;
struct DECLSPEC_DRECORD sqlite3_blob
{
};


struct sqlite3_mutex_methods;
struct DECLSPEC_DRECORD sqlite3_str
{
};


struct DECLSPEC_DRECORD sqlite3_pcache
{
};


struct sqlite3_pcache_page;
struct sqlite3_pcache_methods2;
struct sqlite3_pcache_methods;
struct DECLSPEC_DRECORD sqlite3_backup
{
};


struct sqlite3_snapshot;
struct sqlite3_api_routines;
struct sqlite3_tokenizer_module;
struct sqlite3_tokenizer;
struct sqlite3_tokenizer_cursor;
struct DECLSPEC_DRECORD Fts5Context
{
};


struct Fts5PhraseIter;
struct Fts5ExtensionApi;
struct DECLSPEC_DRECORD Fts5Tokenizer
{
};


struct fts5_tokenizer;
struct fts5_api;
struct DECLSPEC_DRECORD sqlite3rbu
{
};


struct sqlite3_rtree_geometry;
struct sqlite3_rtree_query_info;
struct DECLSPEC_DRECORD sqlite3expert
{
};


struct DECLSPEC_DRECORD sqlite3_session
{
};


struct DECLSPEC_DRECORD sqlite3_changeset_iter
{
};


struct DECLSPEC_DRECORD sqlite3_changegroup
{
};


struct DECLSPEC_DRECORD sqlite3_rebaser
{
};


struct Hash;
struct busyHandler;
struct DB;
struct LookasideSlot;
struct Lookaside;
struct sqlite3_int;
class DELPHICLASS ESQLite3;
//-- type declarations -------------------------------------------------------
typedef System::Int8 C___int8;

typedef short C___int16;

typedef int C___int32;

typedef __int64 C___int64;

typedef System::Byte C___uint8;

typedef System::Word C___uint16;

typedef unsigned C___uint32;

typedef unsigned __int64 C___uint64;

typedef char C_char;

typedef char * C_char_ptr;

typedef char * *C_char_ptr_ptr;

typedef C_char_ptr_ptr *C_char_ptr_ptr_ptr;

typedef System::StaticArray<char *, 536870911> C_char_ptr_array;

typedef C_char_ptr_array *C_char_ptr_array_ptr;

typedef System::Int8 C_char_num;

typedef System::Int8 *C_char_num_ptr;

typedef double C_double;

typedef double *C_double_ptr;

typedef float C_float;

typedef float *C_float_ptr;

typedef System::Extended C_long_double;

typedef System::Extended *C_long_double_ptr;

typedef int C_int;

typedef int *C_int_ptr;

typedef C_int_ptr *C_int_ptr_ptr;

typedef System::Int8 C_int8_t;

typedef System::Int8 *C_int8_t_ptr;

typedef short C_int16_t;

typedef short *C_int16_t_ptr;

typedef int C_int32_t;

typedef int *C_int32_t_ptr;

typedef __int64 C_int64_t;

typedef __int64 *C_int64_t_ptr;

typedef System::StaticArray<int, 536870911> C_int_array;

typedef C_int_array *C_int_array_ptr;

typedef System::StaticArray<System::Int8, 2147483647> C_int8_t_array;

typedef C_int8_t_array *C_int8_t_array_ptr;

typedef System::StaticArray<short, 1073741823> C_int16_t_array;

typedef C_int16_t_array *C_int16_t_array_ptr;

typedef System::StaticArray<int, 536870911> C_int32_t_array;

typedef C_int32_t_array *C_int32_t_array_ptr;

typedef System::StaticArray<__int64, 268435455> C_int64_t_array;

typedef C_int64_t_array *C_int64_t_array_ptr;

typedef int C_long;

typedef int *C_long_ptr;

typedef __int64 C_long_long;

typedef __int64 *C_long_long_ptr;

typedef int C_long_int;

typedef int C_long_int_ptr;

typedef short C_short;

typedef short *C_short_ptr;

typedef short C_short_int;

typedef short *C_short_int_ptr;

typedef System::Int8 C_signed_char;

typedef System::Int8 *C_signed_char_ptr;

typedef int C_signed_int;

typedef int *C_signed_int_ptr;

typedef int C_signed_long;

typedef int *C_signed_long_ptr;

typedef __int64 C_signed_long_long;

typedef __int64 *C_signed_long_long_ptr;

typedef short C_signed_short;

typedef unsigned C_unsigned;

typedef unsigned *C_unsigned_ptr;

typedef char C_unsigned_char;

typedef char * C_unsigned_char_ptr;

typedef char * *C_unsigned_char_ptr_ptr;

typedef System::StaticArray<char, 2147483647> C_unsigned_char_array;

typedef C_unsigned_char_array *C_unsigned_char_array_ptr;

typedef System::Byte C_unsigned_char_num;

typedef System::Byte *C_unsigned_char_num_ptr;

typedef System::StaticArray<char *, 536870911> C_unsigned_char_ptr_array;

typedef C_unsigned_char_ptr_array *C_unsigned_char_ptr_array_ptr;

typedef System::StaticArray<System::Byte, 2147483647> C_unsigned_char_num_array;

typedef C_unsigned_char_num_array *C_unsigned_char_num_array_ptr;

typedef C_unsigned_char_num_array_ptr *C_unsigned_char_num_array_ptr_ptr;

typedef unsigned C_unsigned_int;

typedef unsigned *C_unsigned_int_ptr;

typedef unsigned __int64 C_unsigned___int64;

typedef unsigned C_unsigned_long;

typedef unsigned *C_unsigned_long_ptr;

typedef int C_unsigned_long_int;

typedef unsigned __int64 C_unsigned_long_long;

typedef System::Word C_unsigned_short;

typedef System::Word *C_unsigned_short_ptr;

typedef System::Word C_unsigned_short_int;

typedef System::Word *C_unsigned_short_int_ptr;

typedef int C_errno_t;

typedef int C_ptrdiff_t;

typedef unsigned C_size_t;

typedef unsigned *C_size_t_ptr;

typedef System::StaticArray<unsigned, 536870911> C_size_t_array;

typedef C_size_t_array *C_size_t_array_ptr;

typedef int C_ssize_t;

typedef int *C_ssize_t_ptr;

typedef System::StaticArray<int, 536870911> C_ssize_t_array;

typedef C_ssize_t_array *C_ssize_t_array_ptr;

typedef System::Byte C_uint8_t;

typedef System::Byte *C_uint8_t_ptr;

typedef C_uint8_t_ptr *C_uint8_t_ptr_ptr;

typedef System::StaticArray<System::Byte, 2147483647> C_uint8_t_array;

typedef C_uint8_t_array *C_uint8_t_array_ptr;

typedef System::Word C_uint16_t;

typedef System::Word *C_uint16_t_ptr;

typedef System::StaticArray<System::Word, 1073741823> C_uint16_t_array;

typedef C_uint16_t_array *C_uint16_t_array_ptr;

typedef unsigned C_uint32_t;

typedef unsigned *C_uint32_t_ptr;

typedef System::StaticArray<unsigned, 536870911> C_uint32_t_array;

typedef C_uint32_t_array *C_uint32_t_array_ptr;

typedef unsigned __int64 C_uint64_t;

typedef unsigned __int64 *C_uint64_t_ptr;

typedef System::StaticArray<unsigned __int64, 268435455> C_uint64_t_array;

typedef C_uint64_t_array *C_uint64_t_array_ptr;

typedef void * C_void_ptr;

typedef void * *C_void_ptr_ptr;

typedef System::StaticArray<void *, 536870911> C_void_ptr_array;

typedef C_void_ptr_array *C_void_ptr_array_ptr;

typedef System::WideChar C_wchar_t;

typedef System::WideChar C_wint_t;

typedef System::WideChar * C_wchar_t_ptr;

typedef System::WideChar * *C_wchar_t_ptr_ptr;

typedef System::StaticArray<double, 268435455> sqlite3_double_array;

typedef sqlite3_double_array *sqlite3_double_array_ptr;

typedef sqlite3 *sqlite3_ptr;

typedef sqlite3_ptr *sqlite3_ptr_ptr;

typedef __int64 sqlite3_int64;

typedef __int64 *sqlite3_int64_ptr;

typedef unsigned __int64 sqlite3_uint64;

typedef unsigned __int64 *sqlite3_uint64_ptr;

typedef unsigned __int64 sqlite_int64 _DEPRECATED_ATTRIBUTE0 ;

typedef unsigned __int64 *sqlite_int64_ptr;

typedef unsigned __int64 sqlite_uint64 _DEPRECATED_ATTRIBUTE0 ;

typedef unsigned __int64 *sqlite_uint64_ptr;

typedef int __fastcall (*TSQLite3_Callback)(void * UserData, int ColumnCount, Disystemcompat::PPUtf8CharArray ColumnValues, Disystemcompat::PPUtf8CharArray ColumnNames);

typedef sqlite3_io_methods *sqlite3_io_methods_ptr;

struct DECLSPEC_DRECORD sqlite3_file
{
public:
	sqlite3_io_methods *pMethods;
};


typedef sqlite3_file *sqlite3_file_ptr;

struct DECLSPEC_DRECORD sqlite3_io_methods
{
public:
	int iVersion;
	int __fastcall (*xClose)(sqlite3_file_ptr FD);
	int __fastcall (*xRead)(sqlite3_file_ptr FD, void * pBuf, int iAmt, __int64 iOfst);
	int __fastcall (*xWrite)(sqlite3_file_ptr FD, const void * pBuf, int iAmt, __int64 iOfst);
	int __fastcall (*xTruncate)(sqlite3_file_ptr FD, __int64 Size);
	int __fastcall (*xSync)(sqlite3_file_ptr FD, int Flags);
	int __fastcall (*xFileSize)(sqlite3_file_ptr FD, sqlite3_int64_ptr pSize);
	int __fastcall (*xLock)(sqlite3_file_ptr FD, int lockType);
	int __fastcall (*xUnlock)(sqlite3_file_ptr FD, int lockType);
	int __fastcall (*xCheckReservedLock)(sqlite3_file_ptr FD, C_int_ptr pResOut);
	int __fastcall (*xFileControl)(sqlite3_file_ptr FD, int op, void * pArg);
	int __fastcall (*xSectorSize)(sqlite3_file_ptr FD);
	int __fastcall (*xDeviceCharacteristics)(sqlite3_file_ptr FD);
	int __fastcall (*xShmMap)(sqlite3_file_ptr FD, int iRegion, int szRegion, int isWrite, C_void_ptr_ptr Volatile);
	int __fastcall (*xShmLock)(sqlite3_file_ptr FD, int Offset, int n, int Flags);
	void __fastcall (*xShmBarrier)(sqlite3_file_ptr FD);
	int __fastcall (*xShmUnmap)(sqlite3_file_ptr FD, int deleteFlag);
	int __fastcall (*xFetch)(sqlite3_file_ptr FD, __int64 iOfst, int iAmt, C_void_ptr_ptr pp);
	int __fastcall (*xUnfetch)(sqlite3_file_ptr FD, __int64 iOfst, void * p);
};


typedef sqlite3_mutex *sqlite3_mutex_ptr;

typedef void __fastcall (*sqlite3_vfs_xDlSym_result)();

typedef void __fastcall (*sqlite3_syscall_ptr)();

typedef sqlite3_vfs *sqlite3_vfs_ptr;

typedef sqlite3_vfs_ptr *sqlite3_vfs_ptr_ptr;

struct DECLSPEC_DRECORD sqlite3_vfs
{
public:
	int iVersion;
	int szOsFile;
	int mxPathname;
	sqlite3_vfs *pNext;
	char *zName;
	void *pAppData;
	int __fastcall (*xOpen)(sqlite3_vfs_ptr pVfs, const char * zName, sqlite3_file_ptr pFile, int Flags, System::PInteger pOutFlags);
	int __fastcall (*xDelete)(sqlite3_vfs_ptr pVfs, const char * zName, int syncDir);
	int __fastcall (*xAccess)(sqlite3_vfs_ptr pVfs, const char * zName, int Flags, System::PInteger pResOut);
	int __fastcall (*xFullPathname)(sqlite3_vfs_ptr pVfs, const char * zName, int nOut, char * zOut);
	void * __fastcall (*xDlOpen)(sqlite3_vfs_ptr pVfs, const char * zFileName);
	void __fastcall (*xDlError)(sqlite3_vfs_ptr pVfs, int nByte, char * zErrMsg);
	sqlite3_vfs_xDlSym_result __fastcall (*xDlSym)(sqlite3_vfs_ptr pVfs, void * pHandle, const char * zSymbol);
	void __fastcall (*xDlClose)(sqlite3_vfs_ptr pVfs, void * pHandle);
	int __fastcall (*xRandomness)(sqlite3_vfs_ptr pVfs, int nByte, char * zOut);
	int __fastcall (*xSleep)(sqlite3_vfs_ptr pVfs, int MicroSeconds);
	int __fastcall (*xCurrentTime)(sqlite3_vfs_ptr pVfs, System::PDouble pTimeOut);
	int __fastcall (*xGetLastError)(sqlite3_vfs_ptr pVfs, int nBuf, char * zBuf);
	int __fastcall (*xCurrentTimeInt64)(sqlite3_vfs_ptr pVfs, sqlite3_int64_ptr piNow);
	int __fastcall (*xSetSystemCall)(sqlite3_vfs_ptr pVfs, const char * zName, sqlite3_syscall_ptr pNewFunc);
	sqlite3_syscall_ptr __fastcall (*xGetSystemCall)(sqlite3_vfs_ptr pVfs, const char * zName);
	char * __fastcall (*xNextSystemCall)(sqlite3_vfs_ptr pVfs, const char * zName);
};


struct DECLSPEC_DRECORD sqlite3_mem_methods
{
public:
	void * __fastcall (*xMalloc)(int nByte);
	void __fastcall (*xFree)(void * pPrior);
	void * __fastcall (*xRealloc)(void * pPrior, int nByte);
	int __fastcall (*xSize)(void * pPrior);
	int __fastcall (*xRoundup)(int n);
	int __fastcall (*xInit)(void * pAppData);
	void __fastcall (*xShutdown)(void * pAppData);
	void *pAppData;
};


typedef sqlite3_mem_methods *sqlite3_mem_methods_ptr;

typedef int __fastcall (*TSQLite3_Busy_Callback)(void * p, int i);

typedef int __fastcall (*TSQLite3_Authorizer_Callback)(void * UserData, int Arg2, char * Arg3, char * Arg4, char * Arg5, char * Arg6);

typedef void __fastcall (*TSQLite3_Trace_Callback)(void * UserData, const char * SQL);

typedef void __fastcall (*TSQLite3_Profile_Callback)(void * UserData, const char * SQL, __int64 elapseTime);

typedef int __fastcall (*sqlite3_trace_v2_callback)(unsigned t, void * c, void * p, void * x);

typedef int __fastcall (*TSQLite3_Progress_Callback)(void * UserData);

typedef sqlite3_stmt *sqlite3_stmt_ptr;

typedef sqlite3_stmt_ptr *sqlite3_stmt_ptr_ptr;

typedef sqlite3_value *sqlite3_value_ptr;

typedef sqlite3_value_ptr *sqlite3_value_ptr_ptr;

typedef System::StaticArray<sqlite3_value_ptr, 536870911> sqlite3_value_ptr_array;

typedef sqlite3_value_ptr_array *sqlite3_value_ptr_array_ptr;

typedef sqlite3_context *sqlite3_context_ptr;

typedef void __fastcall (*TSQLite3_Destructor)(void * p);

typedef void __fastcall (*TSQLite3_Bind_Destructor)(void * p);

typedef void __fastcall (*sqlite3_bind_pointer_destructor)(void * pPtr);

typedef void __fastcall (*TSQLite3_Func_Callback)(sqlite3_context_ptr pCtx, int nArgs, sqlite3_value_ptr_array_ptr Args);

typedef TSQLite3_Func_Callback *PSQLite_Func_Callback;

typedef void __fastcall (*TSQLite3_Result_Destructor)(void * p);

typedef void __fastcall (*TSQLite3_Step_Callback)(sqlite3_context_ptr pCtx, int nArg, sqlite3_value_ptr_array_ptr apArg);

typedef void __fastcall (*TSQLite3_Final_Callback)(sqlite3_context_ptr pCtx);

typedef void __fastcall (*TSQLite3_Inverse_Callback)(sqlite3_context_ptr pCtx, int nArg, sqlite3_value_ptr_array_ptr apArg);

typedef void __fastcall (*TSQLite3_Value_Callback)(sqlite3_context_ptr pCtx);

typedef void __fastcall (*TSQLite3_Destroy_Callback)(void * pApp);

typedef void __fastcall (*TSQLite3_Memory_Alarm_Callback)(void * pArg, __int64 Used, int n);

typedef void __fastcall (*TSQLite3_AuxData_Destructor)(void * p);

typedef void __fastcall (*sqlite3_result_pointer_destructor)(void * pPtr);

typedef int __fastcall (*TSQLite3_Collation_Callback)(void * UserData, int l1, const void * s1, int l2, const void * s2);

typedef void __fastcall (*TSQLite3_Collation_Destructor)(void * p);

typedef void __fastcall (*TSQLite3_Collation_Needed_Callback)(void * UserData, sqlite3_ptr DB, int eTextRep, char * Name);

typedef void __fastcall (*TSQLite3_Collation_Needed16_Callback)(void * UserData, sqlite3_ptr DB, int eTextRep, System::WideChar * Name);

typedef int __fastcall (*TSQLite3_Commit_Callback)(void * pArg);

typedef void __fastcall (*TSQLite3_Rollback_Callback)(void * pArg);

typedef void __fastcall (*sqlite3_update_hook_callback)(void * pCtx, int op, const char * zDb, const char * zTableName, __int64 RowID);

typedef sqlite3_vtab *sqlite3_vtab_ptr;

typedef sqlite3_vtab_ptr *sqlite3_vtab_ptr_ptr;

typedef sqlite3_index_info *sqlite3_index_info_ptr;

typedef sqlite3_vtab_cursor *sqlite3_vtab_cursor_ptr;

typedef sqlite3_vtab_cursor_ptr *sqlite3_vtab_cursor_ptr_ptr;

struct DECLSPEC_DRECORD sqlite3_module
{
public:
	int iVersion;
	int __fastcall (*xCreate)(sqlite3_ptr DB, void * pAux, int argc, const Disystemcompat::PPUtf8CharArray argv, sqlite3_vtab_ptr_ptr pVTab, Disystemcompat::PPUtf8Char pzErr);
	int __fastcall (*xConnect)(sqlite3_ptr DB, void * pAux, int argc, const Disystemcompat::PPUtf8CharArray argv, sqlite3_vtab_ptr_ptr pVTab, Disystemcompat::PPUtf8Char pzErr);
	int __fastcall (*xBestIndex)(sqlite3_vtab_ptr pVTab, sqlite3_index_info_ptr Info);
	int __fastcall (*xDisconnect)(sqlite3_vtab_ptr pVTab);
	int __fastcall (*xDestroy)(sqlite3_vtab_ptr pVTab);
	int __fastcall (*xOpen)(sqlite3_vtab_ptr pVTab, sqlite3_vtab_cursor_ptr_ptr ppCursor);
	int __fastcall (*xClose)(sqlite3_vtab_cursor_ptr pCursor);
	int __fastcall (*xFilter)(sqlite3_vtab_cursor_ptr pCursor, int idxNum, const char * idxStr, int argc, sqlite3_value_ptr_array_ptr argv);
	int __fastcall (*xNext)(sqlite3_vtab_cursor_ptr pCursor);
	int __fastcall (*xEof)(sqlite3_vtab_cursor_ptr pCursor);
	int __fastcall (*xColumn)(sqlite3_vtab_cursor_ptr pCursor, sqlite3_context_ptr pCtx, int i);
	int __fastcall (*xRowID)(sqlite3_vtab_cursor_ptr pCursor, System::PInt64 pRowID);
	int __fastcall (*xUpdate)(sqlite3_vtab_ptr pVTab, int argc, sqlite3_value_ptr_array_ptr argv, System::PInt64 pRowID);
	int __fastcall (*xBegin)(sqlite3_vtab_ptr pVTab);
	int __fastcall (*xSync)(sqlite3_vtab_ptr pVTab);
	int __fastcall (*xCommit)(sqlite3_vtab_ptr pVTab);
	int __fastcall (*xRollback)(sqlite3_vtab_ptr pVTab);
	int __fastcall (*xFindFunction)(sqlite3_vtab_ptr pVTab, int nArg, const char * zName, PSQLite_Func_Callback pxFunc, sqlite3_value_ptr_array_ptr ppArg);
	int __fastcall (*xRename)(sqlite3_vtab_ptr pVTab, const char * zNew);
	int __fastcall (*xSavepoint)(sqlite3_vtab_ptr pVTab, int iSavepoint);
	int __fastcall (*xRelease)(sqlite3_vtab_ptr pVTab, int iSavepoint);
	int __fastcall (*xRollbackTo)(sqlite3_vtab_ptr pVTab, int iSavepoint);
	int __fastcall (*xShadowName)(const char * zName);
};


typedef sqlite3_module *sqlite3_module_ptr;

struct DECLSPEC_DRECORD sqlite3_vtab
{
public:
	sqlite3_module *pModule;
	int nRef;
	char *zErrMsg;
};


struct DECLSPEC_DRECORD sqlite3_vtab_cursor
{
public:
	sqlite3_vtab *pVTab;
};


struct DECLSPEC_DRECORD sqlite3_index_constraint
{
public:
	int iColumn;
	System::Byte op;
	System::Byte usable;
	int iTermOffset;
};


typedef System::StaticArray<sqlite3_index_constraint, 178956970> sqlite3_index_constraint_array;

typedef sqlite3_index_constraint_array *sqlite3_index_constraint_array_ptr;

struct DECLSPEC_DRECORD sqlite3_index_orderby
{
public:
	int iColumn;
	System::Byte Desc;
};


typedef System::StaticArray<sqlite3_index_orderby, 268435455> sqlite3_index_orderby_array;

typedef sqlite3_index_orderby_array *sqlite3_index_orderby_array_ptr;

struct DECLSPEC_DRECORD sqlite3_index_constraint_usage
{
public:
	int argvIndex;
	System::Byte omit;
};


typedef System::StaticArray<sqlite3_index_constraint_usage, 268435455> sqlite3_index_constraint_usage_array;

typedef sqlite3_index_constraint_usage_array *sqlite3_index_constraint_usage_array_ptr;

struct DECLSPEC_DRECORD sqlite3_index_info
{
public:
	int nConstraint;
	sqlite3_index_constraint_array *aConstraint;
	int nOrderBy;
	sqlite3_index_orderby_array *aOrderBy;
	sqlite3_index_constraint_usage_array *aConstraintUsage;
	int idxNum;
	char *idxStr;
	int needToFreeIdxStr;
	int orderByConsumed;
	double estimatedCost;
	__int64 estimatedRows;
	int idxFlags;
	unsigned __int64 colUsed;
};


typedef void __fastcall (*TSQLite3_Module_Destructor)(void * p);

typedef sqlite3_blob *sqlite3_blob_ptr;

typedef sqlite3_blob_ptr *sqlite3_blob_ptr_ptr;

struct DECLSPEC_DRECORD sqlite3_mutex_methods
{
public:
	int __fastcall (*xMutexInit)();
	int __fastcall (*xMutexEnd)();
	sqlite3_mutex_ptr __fastcall (*xMutexAlloc)(int ID);
	void __fastcall (*xMutexFree)(sqlite3_mutex_ptr p);
	void __fastcall (*xMutexEnter)(sqlite3_mutex_ptr p);
	int __fastcall (*xMutexTry)(sqlite3_mutex_ptr p);
	void __fastcall (*xMutexLeave)(sqlite3_mutex_ptr p);
	int __fastcall (*xMutexHeld)(sqlite3_mutex_ptr p);
	int __fastcall (*xMutexNotheld)(sqlite3_mutex_ptr p);
};


typedef sqlite3_mutex_methods *sqlite3_mutex_methods_ptr;

typedef sqlite3_str *sqlite3_str_ptr;

typedef sqlite3_pcache *sqlite3_pcache_ptr;

struct DECLSPEC_DRECORD sqlite3_pcache_page
{
public:
	void *pBuf;
	void *pExtra;
};


typedef sqlite3_pcache_page *sqlite3_pcache_page_ptr;

struct DECLSPEC_DRECORD sqlite3_pcache_methods2
{
public:
	int iVersion;
	void *pArg;
	int __fastcall (*xInit)(void * pArg);
	void __fastcall (*xShutdown)(void * pArg);
	sqlite3_pcache_ptr __fastcall (*xCreate)(int szPage, int bPurgable);
	void __fastcall (*xCachesize)(sqlite3_pcache_ptr p, int nCacheSize);
	int __fastcall (*xPagecount)(sqlite3_pcache_ptr p);
	sqlite3_pcache_page_ptr __fastcall (*xFetch)(sqlite3_pcache_ptr p, unsigned Key, int createFlag);
	void __fastcall (*xUnpin)(sqlite3_pcache_ptr p, sqlite3_pcache_page_ptr pPg, int discard);
	void __fastcall (*xRekey)(sqlite3_pcache_ptr p, void * pPg, unsigned oldKey, unsigned newKey);
	void __fastcall (*xTruncate)(sqlite3_pcache_ptr p, unsigned iLimit);
	void __fastcall (*xDestroy)(sqlite3_pcache_ptr p);
	void __fastcall (*xShrink)(sqlite3_pcache_ptr p);
};


typedef sqlite3_pcache_methods2 *sqlite3_pcache_methods2_ptr;

struct DECLSPEC_DRECORD sqlite3_pcache_methods
{
public:
	void *pArg;
	int __fastcall (*xInit)(void * pArg);
	void __fastcall (*xShutdown)(void * pArg);
	sqlite3_pcache_ptr __fastcall (*xCreate)(int szPage, int bPurgable);
	void __fastcall (*xCachesize)(sqlite3_pcache_ptr p, int nCacheSize);
	int __fastcall (*xPagecount)(sqlite3_pcache_ptr p);
	void * __fastcall (*xFetch)(sqlite3_pcache_ptr p, unsigned Key, int createFlag);
	void __fastcall (*xUnpin)(sqlite3_pcache_ptr p, void * pPg, int discard);
	void __fastcall (*xRekey)(sqlite3_pcache_ptr p, void * pPg, unsigned oldKey, unsigned newKey);
	void __fastcall (*xTruncate)(sqlite3_pcache_ptr p, unsigned iLimit);
	void __fastcall (*xDestroy)(sqlite3_pcache_ptr p);
};


typedef sqlite3_pcache_methods *sqlite3_pcache_methods_ptr;

typedef sqlite3_backup *sqlite3_backup_ptr;

typedef void __fastcall (*TSQLite3_unlock_notify_callback)(sqlite3_value_ptr_array_ptr apArg, int nArg);

typedef int __fastcall (*sqlite3_wal_hook_callback)(void * pClientData, sqlite3_ptr DB, const char * zDb, int nFrame);

typedef void __fastcall (*sqlite3_preupdate_hook_callback)(void * pCtx, sqlite3_ptr DB, int op, const char * zDb, const char * zName, __int64 iKey1, __int64 iKey2);

struct DECLSPEC_DRECORD sqlite3_snapshot
{
public:
	System::StaticArray<char, 48> hidden;
};


typedef sqlite3_snapshot *sqlite3_snapshot_ptr;

typedef sqlite3_snapshot_ptr *sqlite3_snapshot_ptr_ptr;

typedef sqlite3_api_routines *sqlite3_api_routines_ptr;

typedef int __fastcall (*xEntryPoint)(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const sqlite3_api_routines_ptr pThunk);

struct DECLSPEC_DRECORD sqlite3_api_routines
{
public:
	void * __fastcall (*sqlite3_aggregate_context)(sqlite3_context_ptr pCtx, int nBytes);
	int __fastcall (*sqlite3_aggregate_count)(sqlite3_context_ptr pCtx);
	int __fastcall (*sqlite3_bind_blob)(sqlite3_stmt_ptr pStmt, int ParamIdx, const void * Data, int nData, TSQLite3_Bind_Destructor xDestroy);
	int __fastcall (*sqlite3_bind_double)(sqlite3_stmt_ptr pStmt, int ParamIdx, double Data);
	int __fastcall (*sqlite3_bind_int)(sqlite3_stmt_ptr pStmt, int ParamIdx, int Data);
	int __fastcall (*sqlite3_bind_int64)(sqlite3_stmt_ptr pStmt, int ParamIdx, __int64 Data);
	int __fastcall (*sqlite3_bind_null)(sqlite3_stmt_ptr pStmt, int ParamIdx);
	int __fastcall (*sqlite3_bind_parameter_count)(sqlite3_stmt_ptr pStmt);
	int __fastcall (*sqlite3_bind_parameter_index)(sqlite3_stmt_ptr pStmt, const char * zName);
	char * __fastcall (*sqlite3_bind_parameter_name)(sqlite3_stmt_ptr pStmt, int n);
	int __fastcall (*sqlite3_bind_text)(sqlite3_stmt_ptr pStmt, int ParamIdx, const char * Data, int nData, TSQLite3_Bind_Destructor xDestroy);
	int __fastcall (*sqlite3_bind_text16)(sqlite3_stmt_ptr pStmt, int ParamIdx, const System::WideChar * Data, int nData, TSQLite3_Bind_Destructor xDestroy);
	int __fastcall (*sqlite3_bind_value)(sqlite3_stmt_ptr pStmt, int ParamIdx, const sqlite3_value_ptr pValue);
	int __fastcall (*sqlite3_busy_handler)(sqlite3_ptr DB, TSQLite3_Busy_Callback Callback, void * UserData);
	int __fastcall (*sqlite3_busy_timeout)(sqlite3_ptr DB, int ms);
	int __fastcall (*sqlite3_changes)(sqlite3_ptr DB);
	int __fastcall (*sqlite3_close)(sqlite3_ptr DB);
	int __fastcall (*sqlite3_collation_needed)(sqlite3_ptr DB, void * UserData, TSQLite3_Collation_Needed_Callback Callback);
	int __fastcall (*sqlite3_collation_needed16)(sqlite3_ptr DB, void * UserData, TSQLite3_Collation_Needed16_Callback Callback);
	void * __fastcall (*sqlite3_column_blob)(sqlite3_stmt_ptr pStmt, int iCol);
	int __fastcall (*sqlite3_column_bytes)(sqlite3_stmt_ptr pStmt, int iCol);
	int __fastcall (*sqlite3_column_bytes16)(sqlite3_stmt_ptr pStmt, int iCol);
	int __fastcall (*sqlite3_column_count)(sqlite3_stmt_ptr pStmt);
	char * __fastcall (*sqlite3_column_database_name)(sqlite3_stmt_ptr pStmt, int n);
	System::WideChar * __fastcall (*sqlite3_column_database_name16)(sqlite3_stmt_ptr pStmt, int n);
	char * __fastcall (*sqlite3_column_decltype)(sqlite3_stmt_ptr pStmt, int n);
	System::WideChar * __fastcall (*sqlite3_column_decltype16)(sqlite3_stmt_ptr pStmt, int n);
	double __fastcall (*sqlite3_column_double)(sqlite3_stmt_ptr pStmt, int iCol);
	int __fastcall (*sqlite3_column_int)(sqlite3_stmt_ptr pStmt, int iCol);
	__int64 __fastcall (*sqlite3_column_int64)(sqlite3_stmt_ptr pStmt, int iCol);
	char * __fastcall (*sqlite3_column_name)(sqlite3_stmt_ptr pStmt, int n);
	System::WideChar * __fastcall (*sqlite3_column_name16)(sqlite3_stmt_ptr pStmt, int n);
	char * __fastcall (*sqlite3_column_origin_name)(sqlite3_stmt_ptr pStmt, int n);
	System::WideChar * __fastcall (*sqlite3_column_origin_name16)(sqlite3_stmt_ptr pStmt, int n);
	char * __fastcall (*sqlite3_column_table_name)(sqlite3_stmt_ptr pStmt, int n);
	System::WideChar * __fastcall (*sqlite3_column_table_name16)(sqlite3_stmt_ptr pStmt, int n);
	char * __fastcall (*sqlite3_column_text)(sqlite3_stmt_ptr pStmt, int iCol);
	System::WideChar * __fastcall (*sqlite3_column_text16)(sqlite3_stmt_ptr pStmt, int iCol);
	int __fastcall (*sqlite3_column_type)(sqlite3_stmt_ptr pStmt, int iCol);
	sqlite3_value __fastcall (*sqlite3_column_value)(sqlite3_stmt_ptr pStmt, int iCol);
	void * __fastcall (*sqlite3_commit_hook)(sqlite3_ptr DB, TSQLite3_Commit_Callback Callback, void * pArg);
	int __fastcall (*sqlite3_complete)(const char * SQL);
	int __fastcall (*sqlite3_complete16)(const System::WideChar * SQL);
	int __fastcall (*sqlite3_create_collation)(sqlite3_ptr DB, const char * zName, int eTextRep, void * pApp, TSQLite3_Collation_Callback xCompare);
	int __fastcall (*sqlite3_create_collation16)(sqlite3_ptr DB, const System::WideChar * zName, int eTextRep, void * pApp, TSQLite3_Collation_Callback xCompare);
	int __fastcall (*sqlite3_create_function)(sqlite3_ptr DB, const char * zFunctionName, int nArg, int eTextRep, void * pApp, TSQLite3_Func_Callback xFunc, TSQLite3_Step_Callback xStep, TSQLite3_Final_Callback xFinal);
	int __fastcall (*sqlite3_create_function16)(sqlite3_ptr DB, const System::WideChar * zFunctionName, int nArg, int eTextRep, void * pApp, TSQLite3_Func_Callback xFunc, TSQLite3_Step_Callback xStep, TSQLite3_Final_Callback xFinal);
	int __fastcall (*sqlite3_create_module)(sqlite3_ptr DB, const char * zName, const sqlite3_module_ptr Module, void * pClientData);
	int __fastcall (*sqlite3_data_count)(sqlite3_stmt_ptr pStmt);
	sqlite3_ptr __fastcall (*sqlite3_db_handle)(sqlite3_stmt_ptr pStmt);
	int __fastcall (*sqlite3_declare_vtab)(sqlite3_ptr DB, const char * zCreateTable);
	int __fastcall (*sqlite3_enable_shared_cache)(int Value);
	int __fastcall (*sqlite3_errcode)(sqlite3_ptr DB);
	char * __fastcall (*sqlite3_errmsg)(sqlite3_ptr DB);
	System::WideChar * __fastcall (*sqlite3_errmsg16)(sqlite3_ptr DB);
	int __fastcall (*sqlite3_exec)(sqlite3_ptr DB, const char * SQL, TSQLite3_Callback Callback, void * UserData, Disystemcompat::PPUtf8Char ErrMsg);
	int __fastcall (*sqlite3_expired)(sqlite3_ptr pStmt);
	int __fastcall (*sqlite3_finalize)(sqlite3_stmt_ptr pStmt);
	void __fastcall (*sqlite3_free)(void * p);
	void __fastcall (*sqlite3_free_table)(Disystemcompat::PPUtf8CharArray resultp);
	int __fastcall (*sqlite3_get_autocommit)(sqlite3_ptr DB);
	void * __fastcall (*sqlite3_get_auxdata)(sqlite3_context_ptr pCtx, int nArg);
	int __fastcall (*sqlite3_get_table)(sqlite3_ptr DB, const char * zSql, Disystemcompat::PPPUtf8CharArray pazResult, System::PInteger pnRow, System::PInteger pnColumn, Disystemcompat::PPUtf8Char pzErrMsg);
	int __fastcall (*sqlite3_global_recover)();
	void __fastcall (*sqlite3_interrupt)(sqlite3_ptr DB);
	__int64 __fastcall (*sqlite3_last_insert_rowid)(sqlite3_ptr DB);
	char * __fastcall (*sqlite3_libversion)();
	int __fastcall (*sqlite3_libversion_number)();
	void * __fastcall (*sqlite3_malloc)(int nByte);
	char * __cdecl (*sqlite3_mprintf)(char * zFormat);
	int __fastcall (*sqlite3_open)(char * FileName, sqlite3_ptr_ptr ppDB);
	int __fastcall (*sqlite3_open16)(System::WideChar * FileName, sqlite3_ptr_ptr ppDB);
	int __fastcall (*sqlite3_prepare)(sqlite3_ptr DB, const char * zSql, int nByte, sqlite3_stmt_ptr_ptr ppStmt, const C_char_ptr_ptr pzTail);
	int __fastcall (*sqlite3_prepare16)(sqlite3_ptr DB, const System::WideChar * zSql, int nByte, sqlite3_stmt_ptr_ptr ppStmt, const System::PPWideChar pzTail);
	void * __fastcall (*sqlite3_profile)(sqlite3_ptr DB, TSQLite3_Profile_Callback Callback, void * UserData);
	void __fastcall (*sqlite3_progress_handler)(sqlite3_ptr DB, int n, TSQLite3_Progress_Callback Callback, void * UserData);
	void * __fastcall (*sqlite3_realloc)(void * pOld, int nByte);
	int __fastcall (*sqlite3_reset)(sqlite3_stmt_ptr pStmt);
	void __fastcall (*sqlite3_result_blob)(sqlite3_context_ptr pCtx, const void * Data, int nData, TSQLite3_Result_Destructor xDestroy);
	void __fastcall (*sqlite3_result_double)(sqlite3_context_ptr pCtx, const double Data);
	void __fastcall (*sqlite3_result_error)(sqlite3_context_ptr pCtx, const char * Data, int nData);
	void __fastcall (*sqlite3_result_error16)(sqlite3_context_ptr pCtx, const System::WideChar * Data, int nData);
	void __fastcall (*sqlite3_result_int)(sqlite3_context_ptr pCtx, const int Data);
	void __fastcall (*sqlite3_result_int64)(sqlite3_context_ptr pCtx, const __int64 Data);
	void __fastcall (*sqlite3_result_null)(sqlite3_context_ptr pCtx);
	void __fastcall (*sqlite3_result_text)(sqlite3_context_ptr pCtx, const char * Data, int nData, TSQLite3_Result_Destructor xDestroy);
	void __fastcall (*sqlite3_result_text16)(sqlite3_context_ptr pCtx, const System::WideChar * Data, int nData, TSQLite3_Result_Destructor xDestroy);
	void __fastcall (*sqlite3_result_text16be)(sqlite3_context_ptr pCtx, const System::WideChar * Data, int nData, TSQLite3_Result_Destructor xDestroy);
	void __fastcall (*sqlite3_result_text16le)(sqlite3_context_ptr pCtx, const System::WideChar * Data, int nData, TSQLite3_Result_Destructor xDestroy);
	void __fastcall (*sqlite3_result_value)(sqlite3_context_ptr pCtx, sqlite3_value_ptr pValue);
	void * __fastcall (*sqlite3_rollback_hook)(sqlite3_ptr DB, TSQLite3_Rollback_Callback Callback, void * pArg);
	int __fastcall (*sqlite3_set_authorizer)(sqlite3_ptr DB, TSQLite3_Authorizer_Callback Callback, void * UserData);
	void __fastcall (*sqlite3_set_auxdata)(sqlite3_context_ptr pCtx, int nArg, void * pAux, TSQLite3_AuxData_Destructor xDestroy);
	char * __cdecl (*sqlite3_snprintf)(int BufSize, char * zBuf, char * zFormat);
	int __fastcall (*sqlite3_step)(sqlite3_stmt_ptr pStmt);
	int __fastcall (*sqlite3_table_column_metadata)(sqlite3_ptr DB, const char * zDbName, const char * zTableName, const char * zColumnName, const Disystemcompat::PPUtf8Char pzDataType, const Disystemcompat::PPUtf8Char pzCollSeq, System::PInteger pNotNull, System::PInteger pPrimaryKey, System::PInteger pAutoInc);
	void __fastcall (*sqlite3_thread_cleanup)();
	int __fastcall (*sqlite3_total_changes)(sqlite3_ptr DB);
	void * __fastcall (*sqlite3_trace)(sqlite3_ptr DB, TSQLite3_Trace_Callback Callback, void * UserData);
	int __fastcall (*sqlite3_transfer_bindings)(sqlite3_stmt_ptr pFromStmt, sqlite3_stmt_ptr pToStmt);
	void * __fastcall (*sqlite3_update_hook)(sqlite3_ptr DB, sqlite3_update_hook_callback xCallback, void * Part);
	void * __fastcall (*sqlite3_user_data)(sqlite3_context_ptr pCtx);
	void * __fastcall (*sqlite3_value_blob)(sqlite3_value_ptr pValue);
	int __fastcall (*sqlite3_value_bytes)(sqlite3_value_ptr pValue);
	int __fastcall (*sqlite3_value_bytes16)(sqlite3_value_ptr pValue);
	double __fastcall (*sqlite3_value_double)(sqlite3_value_ptr pValue);
	int __fastcall (*sqlite3_value_int)(sqlite3_value_ptr pValue);
	__int64 __fastcall (*sqlite3_value_int64)(sqlite3_value_ptr pValue);
	int __fastcall (*sqlite3_value_numeric_type)(sqlite3_value_ptr pValue);
	char * __fastcall (*sqlite3_value_text)(sqlite3_value_ptr pValue);
	System::WideChar * __fastcall (*sqlite3_value_text16)(sqlite3_value_ptr pValue);
	System::WideChar * __fastcall (*sqlite3_value_text16be)(sqlite3_value_ptr pValue);
	System::WideChar * __fastcall (*sqlite3_value_text16le)(sqlite3_value_ptr pValue);
	int __fastcall (*sqlite3_value_type)(sqlite3_value_ptr pValue);
	void __fastcall (*sqlite3_vmprintf)();
	int __fastcall (*sqlite3_overload_function)(sqlite3_ptr DB, const char * zFuncName, int nArg);
	int __fastcall (*sqlite3_prepare_v2)(sqlite3_ptr DB, const char * zSql, int nByte, sqlite3_stmt_ptr_ptr ppStmt, const C_char_ptr_ptr pzTail);
	int __fastcall (*sqlite3_prepare16_v2)(sqlite3_ptr DB, const System::WideChar * zSql, int nBytes, sqlite3_stmt_ptr_ptr ppStmt, const System::PPWideChar pzTail);
	int __fastcall (*sqlite3_clear_bindings)(sqlite3_stmt_ptr pStmt);
	int __fastcall (*sqlite3_create_module_v2)(sqlite3_ptr DB, const char * zName, const sqlite3_module_ptr Module, void * pClientData, TSQLite3_Module_Destructor xDestroy);
	int __fastcall (*sqlite3_bind_zeroblob)(sqlite3_stmt_ptr pStmt, int ParamIdx, int nData);
	int __fastcall (*sqlite3_blob_bytes)(sqlite3_blob_ptr pBlob);
	int __fastcall (*sqlite3_blob_close)(sqlite3_blob_ptr pBlob);
	int __fastcall (*sqlite3_blob_open)(sqlite3_ptr DB, const char * zDb, const char * zTable, const char * zColumn, __int64 iRow, int Flags, sqlite3_blob_ptr_ptr ppBlob);
	int __fastcall (*sqlite3_blob_read)(sqlite3_blob_ptr pBlob, void * z, int n, int iOffset);
	int __fastcall (*sqlite3_blob_write)(sqlite3_blob_ptr pBlob, const void * z, int n, int iOffset);
	int __fastcall (*sqlite3_create_collation_v2)(sqlite3_ptr DB, const char * zName, int eTextRep, void * pApp, TSQLite3_Collation_Callback xCompare, TSQLite3_Collation_Destructor xDestroy);
	int __fastcall (*sqlite3_file_control)(sqlite3_ptr DB, const char * zDbName, int op, void * pArg);
	__int64 __fastcall (*sqlite3_memory_highwater)(int resetFlag);
	__int64 __fastcall (*sqlite3_memory_used)();
	sqlite3_mutex_ptr __fastcall (*sqlite3_mutex_alloc)(int iType);
	void __fastcall (*sqlite3_mutex_enter)(sqlite3_mutex_ptr p);
	void __fastcall (*sqlite3_mutex_free)(sqlite3_mutex_ptr p);
	void __fastcall (*sqlite3_mutex_leave)(sqlite3_mutex_ptr p);
	int __fastcall (*sqlite3_mutex_try)(sqlite3_mutex_ptr p);
	int __fastcall (*sqlite3_open_v2)(const char * FileName, sqlite3_ptr_ptr ppDB, int Flags, const char * zVfs);
	int __fastcall (*sqlite3_release_memory)(int n);
	void __fastcall (*sqlite3_result_error_nomem)(sqlite3_context_ptr pCtx);
	void __fastcall (*sqlite3_result_error_toobig)(sqlite3_context_ptr pCtx);
	int __fastcall (*sqlite3_sleep)(int ms);
	void __fastcall (*sqlite3_soft_heap_limit)(int n);
	sqlite3_vfs_ptr __fastcall (*sqlite3_vfs_find)(const char * zVfsName);
	int __fastcall (*sqlite3_vfs_register)(sqlite3_vfs_ptr pVfs, int makeDflt);
	int __fastcall (*sqlite3_vfs_unregister)(sqlite3_vfs_ptr pVfs);
	int __fastcall (*sqlite3_threadsafe)();
	void __fastcall (*sqlite3_result_zeroblob)(sqlite3_context_ptr pCtx, int n);
	void __fastcall (*sqlite3_result_error_code)(sqlite3_context_ptr pCtx, int ErrCode);
	int __cdecl (*sqlite3_test_control)(int op);
	void __fastcall (*sqlite3_randomness)(int n, void * p);
	sqlite3_ptr __fastcall (*sqlite3_context_db_handle)(sqlite3_context_ptr pCtx);
	int __fastcall (*sqlite3_extended_result_codes)(sqlite3_ptr DB, int onoff);
	int __fastcall (*sqlite3_limit)(sqlite3_ptr DB, int ID, int newVal);
	sqlite3_stmt_ptr __fastcall (*sqlite3_next_stmt)(sqlite3_ptr pDb, sqlite3_stmt_ptr pStmt);
	char * __fastcall (*sqlite3_sql)(sqlite3_stmt_ptr pStmt);
	int __fastcall (*sqlite3_status)(int op, System::PInteger pCurrent, System::PInteger pHighwater, int resetFlag);
	int __fastcall (*sqlite3_backup_finish)(sqlite3_backup_ptr p);
	sqlite3_backup_ptr __fastcall (*sqlite3_backup_init)(sqlite3_ptr pDest, const char * zDestName, sqlite3_ptr pSource, const char * zSourceName);
	int __fastcall (*sqlite3_backup_pagecount)(sqlite3_backup_ptr p);
	int __fastcall (*sqlite3_backup_remaining)(sqlite3_backup_ptr p);
	int __fastcall (*sqlite3_backup_step)(sqlite3_backup_ptr p, int nPage);
	char * __fastcall (*sqlite3_compileoption_get)(int n);
	int __fastcall (*sqlite3_compileoption_used)(char * zOptName);
	int __fastcall (*sqlite3_create_function_v2)(sqlite3_ptr DB, const char * zFunctionName, int nArg, int eTextRep, void * pApp, TSQLite3_Func_Callback xFunc, TSQLite3_Step_Callback xStep, TSQLite3_Final_Callback xFinal, TSQLite3_Destroy_Callback xDestroy);
	int __cdecl (*sqlite3_db_config)(sqlite3_ptr DB, int op);
	sqlite3_mutex_ptr __fastcall (*sqlite3_db_mutex)(sqlite3_ptr DB);
	int __fastcall (*sqlite3_db_status)(sqlite3_ptr DB, int op, C_int_ptr pCurrent, C_int_ptr pHighwater, int resetFlag);
	int __fastcall (*sqlite3_extended_errcode)(sqlite3_ptr DB);
	void __cdecl (*sqlite3_log)(int iErrCode, const char * zFormat);
	__int64 __fastcall (*sqlite3_soft_heap_limit64)(__int64 n);
	char * __fastcall (*sqlite3_sourceid)();
	int __fastcall (*sqlite3_stmt_status)(sqlite3_stmt_ptr Stmt, int op, int resetFlg);
	int __fastcall (*sqlite3_strnicmp)(const char * zLeft, const char * zRight, int n);
	int __fastcall (*sqlite3_unlock_notify)(sqlite3_ptr pBlocked, TSQLite3_unlock_notify_callback xNotify, void * pNotifyArg);
	int __fastcall (*sqlite3_wal_autocheckpoint)(sqlite3_ptr DB, int nFrame);
	int __fastcall (*sqlite3_wal_checkpoint)(sqlite3_ptr DB, const char * zDb);
	void * __fastcall (*sqlite3_wal_hook)(sqlite3_ptr DB, sqlite3_wal_hook_callback xCallback, void * pArg);
	int __fastcall (*sqlite3_blob_reopen)(sqlite3_blob_ptr pBlob, __int64 iRow);
	int __cdecl (*sqlite3_vtab_config)(sqlite3_ptr DB, int op);
	int __fastcall (*sqlite3_vtab_on_conflict)(sqlite3_ptr DB);
	int __fastcall (*sqlite3_close_v2)(sqlite3_ptr DB);
	char * __fastcall (*sqlite3_db_filename)(sqlite3_ptr DB, const char * zDbName);
	int __fastcall (*sqlite3_db_readonly)(sqlite3_ptr DB, const char * zDbName);
	int __fastcall (*sqlite3_db_release_memory)(sqlite3_ptr DB);
	char * __fastcall (*sqlite3_errstr)(int RC);
	int __fastcall (*sqlite3_stmt_busy)(sqlite3_stmt_ptr pStmt);
	int __fastcall (*sqlite3_stmt_readonly)(sqlite3_stmt_ptr pStmt);
	int __fastcall (*sqlite3_stricmp)(const char * zLeft, const char * zRight);
	int __fastcall (*sqlite3_uri_boolean)(const char * zFileName, const char * zParam, int bDflt);
	__int64 __fastcall (*sqlite3_uri_int64)(const char * zFileName, const char * zParam, __int64 bDflt);
	char * __fastcall (*sqlite3_uri_parameter)(const char * zFileName, const char * zParam);
	char * __cdecl (*sqlite3_vsnprintf)();
	int __fastcall (*sqlite3_wal_checkpoint_v2)(sqlite3_ptr DB, const char * zDb, int eMode, C_int_ptr pnLog, C_int_ptr pnCkpt);
	int __fastcall (*sqlite3_auto_extension)(xEntryPoint xEntryPoint);
	int __fastcall (*sqlite3_bind_blob64)(sqlite3_stmt_ptr pStmt, int ParamIdx, const void * zData, unsigned __int64 nData, TSQLite3_Bind_Destructor xDestroy);
	int __fastcall (*sqlite3_bind_text64)(sqlite3_stmt_ptr pStmt, int ParamIdx, const char * zData, unsigned __int64 nData, TSQLite3_Bind_Destructor xDestroy, System::Byte Encoding);
	int __fastcall (*sqlite3_cancel_auto_extension)(xEntryPoint xEntryPoint);
	int __fastcall (*sqlite3_load_extension)(sqlite3_ptr DB, const char * zFile, const char * zProc, C_char_ptr_ptr pzErrMsg);
	void * __fastcall (*sqlite3_malloc64)(unsigned __int64 n);
	unsigned __int64 __fastcall (*sqlite3_msize)(void * p);
	void * __fastcall (*sqlite3_realloc64)(void * pOld, unsigned __int64 n);
	void __fastcall (*sqlite3_reset_auto_extension)();
	void __fastcall (*sqlite3_result_blob64)(sqlite3_context_ptr pCtx, const void * zData, unsigned __int64 nData, TSQLite3_Result_Destructor xDestroy);
	void __fastcall (*sqlite3_result_text64)(sqlite3_context_ptr pCtx, const char * zData, unsigned __int64 nData, TSQLite3_Result_Destructor xDestroy, System::Byte Encoding);
	int __fastcall (*sqlite3_strglob)(const char * zGlob, const char * zStr);
	sqlite3_value_ptr __fastcall (*sqlite3_value_dup)(const sqlite3_value_ptr pOrig);
	void __fastcall (*sqlite3_value_free)(sqlite3_value_ptr pOld);
	int __fastcall (*sqlite3_result_zeroblob64)(sqlite3_context_ptr pCtx, unsigned __int64 n);
	int __fastcall (*sqlite3_bind_zeroblob64)(sqlite3_stmt_ptr pStmt, int i, unsigned __int64 n);
	unsigned __fastcall (*sqlite3_value_subtype)(sqlite3_value_ptr pValue);
	void __fastcall (*sqlite3_result_subtype)(sqlite3_context_ptr pCtx, unsigned eSubtype);
	int __fastcall (*sqlite3_status64)(int op, sqlite3_int64_ptr pCurrent, sqlite3_int64_ptr pHighwater, int resetFlag);
	int __fastcall (*sqlite3_strlike)(const char * zGlob, const char * zStr, unsigned cEsc);
	int __fastcall (*sqlite3_db_cacheflush)(sqlite3_ptr DB);
	int __fastcall (*sqlite3_system_errno)(sqlite3_ptr DB);
	int __fastcall (*sqlite3_trace_v2)(sqlite3_ptr DB, unsigned uMask, sqlite3_trace_v2_callback xCallback, void * pCtx);
	char * __fastcall (*sqlite3_expanded_sql)(sqlite3_stmt_ptr pStmt);
	void __fastcall (*sqlite3_set_last_insert_rowid)(sqlite3_ptr DB, __int64 iRowId);
	int __fastcall (*sqlite3_prepare_v3)(sqlite3_ptr DB, const char * SQL, int nByte, unsigned prepFlags, sqlite3_stmt_ptr_ptr ppStmt, const C_char_ptr_ptr pzTrail);
	int __fastcall (*sqlite3_prepare16_v3)(sqlite3_ptr DB, const System::WideChar * SQL, int nByte, unsigned prepFlags, sqlite3_stmt_ptr_ptr ppStmt, const System::PPWideChar pzTrail);
	int __fastcall (*sqlite3_bind_pointer)(sqlite3_stmt_ptr pStmt, int i, void * pPtr, const char * zPType, sqlite3_bind_pointer_destructor xDestructor);
	void __fastcall (*sqlite3_result_pointer)(sqlite3_context_ptr pCtx, void * pValue, const char * zPType, sqlite3_result_pointer_destructor xDestructor);
	void * __fastcall (*sqlite3_value_pointer)(sqlite3_value_ptr pValue, const char * zPType);
	int __fastcall (*sqlite3_vtab_nochange)(sqlite3_context_ptr pCtx);
	int __fastcall (*sqlite3_value_nochange)(sqlite3_value_ptr pValue);
	char * __fastcall (*sqlite3_vtab_collation)(sqlite3_index_info_ptr pIdxInfo, int iCons);
	int __fastcall (*sqlite3_keyword_count)();
	int __fastcall (*sqlite3_keyword_name)(int Idx, const C_char_ptr_ptr p, C_int_ptr l);
	int __fastcall (*sqlite3_keyword_check)(const char * a, int b);
	sqlite3_str_ptr __fastcall (*sqlite3_str_new)(sqlite3_ptr DB);
	char * __fastcall (*sqlite3_str_finish)(sqlite3_str_ptr p);
	void __cdecl (*sqlite3_str_appendf)(sqlite3_str_ptr p, const char * zFormat);
	void __cdecl (*sqlite3_str_vappendf)(sqlite3_str_ptr p, const char * zFormat, void * ap);
	void __fastcall (*sqlite3_str_append)(sqlite3_str_ptr p, const char * zIn, int n);
	void __fastcall (*sqlite3_str_appendall)(sqlite3_str_ptr p, const char * zIn);
	void __fastcall (*sqlite3_str_appendchar)(sqlite3_str_ptr p, int n, char c);
	void __fastcall (*sqlite3_str_reset)(sqlite3_str_ptr p);
	int __fastcall (*sqlite3_str_errcode)(sqlite3_str_ptr p);
	int __fastcall (*sqlite3_str_length)(sqlite3_str_ptr p);
	char * __fastcall (*sqlite3_str_value)(sqlite3_str_ptr p);
	int __fastcall (*sqlite3_create_window_function)(sqlite3_ptr DB, const char * zFunctionName, int nArg, int eTextRep, void * pApp, TSQLite3_Step_Callback xStep, TSQLite3_Final_Callback xFinal, TSQLite3_Value_Callback xValue, TSQLite3_Inverse_Callback xInverse, TSQLite3_Destroy_Callback xDestroy);
	char * __fastcall (*sqlite3_normalized_sql)(sqlite3_stmt_ptr pStmt);
	int __fastcall (*sqlite3_stmt_isexplain)(sqlite3_stmt_ptr pStmt);
	int __fastcall (*sqlite3_value_frombind)(sqlite3_value_ptr pValue);
	int __fastcall (*sqlite3_drop_modules)(sqlite3_ptr DB, const C_char_ptr_array_ptr azKeep);
	__int64 __fastcall (*sqlite3_hard_heap_limit64)(__int64 n);
	char * __fastcall (*sqlite3_uri_key)(const char * zFileName, int n);
	char * __fastcall (*sqlite3_filename_database)(const char * zFileName);
	char * __fastcall (*sqlite3_filename_journal)(const char * zFileName);
	char * __fastcall (*sqlite3_filename_wal)(const char * zFileName);
	char * __fastcall (*sqlite3_create_filename)(const char * zDatabase, const char * zJournal, const char * zWal, int nParam, const C_char_ptr_array_ptr azParam);
	void __fastcall (*sqlite3_free_filename)(char * p);
	sqlite3_file_ptr __fastcall (*sqlite3_database_file_object)(const char * zName);
	int __fastcall (*sqlite3_txn_state)(sqlite3_ptr DB, const char * zSchema);
};


typedef sqlite3_tokenizer *sqlite3_tokenizer_ptr;

typedef sqlite3_tokenizer_ptr *sqlite3_tokenizer_ptr_ptr;

typedef sqlite3_tokenizer_cursor *sqlite3_tokenizer_cursor_ptr;

typedef sqlite3_tokenizer_cursor_ptr *sqlite3_tokenizer_cursor_ptr_ptr;

struct DECLSPEC_DRECORD sqlite3_tokenizer_module
{
public:
	int iVersion;
	int __fastcall (*xCreate)(int argc, const Disystemcompat::PPUtf8CharArray argv, sqlite3_tokenizer_ptr_ptr ppTokenizer);
	int __fastcall (*xDestroy)(sqlite3_tokenizer_ptr pTokenizer);
	int __fastcall (*xOpen)(sqlite3_tokenizer_ptr pTokenizer, const char * pInput, int nBytes, sqlite3_tokenizer_cursor_ptr_ptr ppCursor);
	int __fastcall (*xClose)(sqlite3_tokenizer_cursor_ptr pCursor);
	int __fastcall (*xNext)(sqlite3_tokenizer_cursor_ptr pCursor, const Disystemcompat::PPUtf8Char ppToken, System::PInteger pnBytes, System::PInteger piStartOffset, System::PInteger piEndOffset, System::PInteger piPosition);
};


typedef sqlite3_tokenizer_module *sqlite3_tokenizer_module_ptr;

struct DECLSPEC_DRECORD sqlite3_tokenizer
{
public:
	sqlite3_tokenizer_module *pModule;
};


struct DECLSPEC_DRECORD sqlite3_tokenizer_cursor
{
public:
	sqlite3_tokenizer *pTokenizer;
};


typedef Fts5Context *Fts5Context_ptr;

typedef Fts5ExtensionApi *Fts5ExtensionApi_ptr;

typedef void __fastcall (*fts5_extension_function)(const Fts5ExtensionApi_ptr pApi, Fts5Context_ptr pFts, sqlite3_context_ptr pCtx, int nVal, sqlite3_value_ptr_array_ptr apVal);

struct DECLSPEC_DRECORD Fts5PhraseIter
{
public:
	char *a;
	char *b;
};


typedef Fts5PhraseIter *Fts5PhraseIter_ptr;

typedef int __fastcall (*Fts5ExtensionApi_xTokenize_xToken)(void * pCtx, int tflags, const char * pToken, int nToken, int iStart, int iEnd);

typedef int __fastcall (*Fts5ExtensionApi_xQueryPhrase_xCallback)(const Fts5ExtensionApi_ptr pApi, Fts5Context_ptr pFts, void * pUserData);

typedef void __fastcall (*Fts5ExtensionApi_xSetAuxdata_xDelete)(void * pAux);

struct DECLSPEC_DRECORD Fts5ExtensionApi
{
public:
	int iVersion;
	void * __fastcall (*xUserData)(Fts5Context_ptr pFts);
	int __fastcall (*xColumnCount)(Fts5Context_ptr pFts);
	int __fastcall (*xRowCount)(Fts5Context_ptr pFts, sqlite3_int64_ptr pnRow);
	int __fastcall (*xColumnTotalSize)(Fts5Context_ptr pFts, int iCol, sqlite3_int64_ptr pnToken);
	int __fastcall (*xTokenize)(Fts5Context_ptr pFts, const char * pText, int nText, void * pCtx, Fts5ExtensionApi_xTokenize_xToken xToken);
	int __fastcall (*xPhraseCount)(Fts5Context_ptr pFts);
	int __fastcall (*xPhraseSize)(Fts5Context_ptr pFts, int iPhrase);
	int __fastcall (*xInstCount)(Fts5Context_ptr pFts, C_int_ptr pnInst);
	int __fastcall (*xInst)(Fts5Context_ptr pFts, int iIdx, C_int_ptr piPhrase, C_int_ptr piCol, C_int_ptr piOff);
	__int64 __fastcall (*xRowID)(Fts5Context_ptr pFts);
	int __fastcall (*xColumnText)(Fts5Context_ptr pFts, int iCol, const C_char_ptr_ptr pz, C_int_ptr pn);
	int __fastcall (*xColumnSize)(Fts5Context_ptr pFts, int iCol, C_int_ptr pnToken);
	int __fastcall (*xQueryphrase)(Fts5Context_ptr pFts, int iPhrase, void * pUserData, Fts5ExtensionApi_xQueryPhrase_xCallback xCallback);
	int __fastcall (*xSetAuxdata)(Fts5Context_ptr pFts, void * pAux, Fts5ExtensionApi_xSetAuxdata_xDelete xDelete);
	void * __fastcall (*xGetAuxdata)(Fts5Context_ptr pFts, int bClear);
	int __fastcall (*xPhraseFirst)(Fts5Context_ptr pFts, int iPhrase, Fts5PhraseIter_ptr pIter, C_int_ptr piCol, C_int_ptr piOff);
	void __fastcall (*xPhraseNext)(Fts5Context_ptr pFts, Fts5PhraseIter_ptr pIter, C_int_ptr piCol, C_int_ptr piOff);
	int __fastcall (*xPhraseFirstColumn)(Fts5Context_ptr pFts, int iPhrase, Fts5PhraseIter_ptr pIter, C_int_ptr piCol);
	void __fastcall (*xPhraseNextColumn)(Fts5Context_ptr pFts, Fts5PhraseIter_ptr pIter, C_int_ptr piCol);
};


typedef Fts5Tokenizer *Fts5Tokenizer_ptr;

typedef Fts5Tokenizer_ptr *Fts5Tokenizer_ptr_ptr;

typedef int __fastcall (*fts5_tokenizer_xTokenize_xToken)(void * pCtx, int tflags, const char * pToken, int nToken, int iStart, int iEnd);

typedef fts5_tokenizer *fts5_tokenizer_ptr;

typedef fts5_tokenizer_ptr *fts5_tokenizer_ptr_ptr;

struct DECLSPEC_DRECORD fts5_tokenizer
{
public:
	int __fastcall (*xCreate)(void * pContext, const C_char_ptr_array_ptr azArg, int nArg, Fts5Tokenizer_ptr_ptr ppOut);
	void __fastcall (*xDelete)(Fts5Tokenizer_ptr pTokenizer);
	int __fastcall (*xTokenize)(Fts5Tokenizer_ptr pTokenizer, void * pCtx, int tflags, const char * pText, int nText, fts5_tokenizer_xTokenize_xToken xToken);
};


typedef void __fastcall (*fts5_api_xCreateTokenizer_xDestroy)(void * p);

typedef void __fastcall (*fts5_api_xCreateFunction_xDestroy)(void * p);

typedef fts5_api *fts5_api_ptr;

typedef fts5_api_ptr *fts5_api_ptr_ptr;

struct DECLSPEC_DRECORD fts5_api
{
public:
	int iVersion;
	int __fastcall (*xCreateTokenizer)(fts5_api_ptr pApi, const char * zName, void * pContext, fts5_tokenizer_ptr pTokenizer, fts5_api_xCreateTokenizer_xDestroy xDestroy);
	int __fastcall (*xFindTokenizer)(fts5_api_ptr pApi, const char * zName, C_void_ptr_ptr ppContext, fts5_tokenizer_ptr pTokenizer);
	int __fastcall (*xCreateFunction)(fts5_api_ptr pApi, const char * zName, void * pContext, fts5_extension_function xFunction, fts5_api_xCreateFunction_xDestroy xDestroy);
};


typedef sqlite3rbu *sqlite3rbu_ptr;

typedef double sqlite3_rtree_dbl;

typedef double *sqlite3_rtree_dbl_ptr;

typedef System::StaticArray<double, 268435455> sqlite3_rtree_dbl_array;

typedef sqlite3_rtree_dbl_array *sqlite3_rtree_dbl_array_ptr;

struct DECLSPEC_DRECORD sqlite3_rtree_geometry
{
public:
	void *pContext;
	int nParam;
	sqlite3_rtree_dbl_array *aParam;
	void *pUser;
	void __fastcall (*xDelUser)(void * pUser);
};


typedef sqlite3_rtree_geometry *sqlite3_rtree_geometry_ptr;

typedef int __fastcall (*sqlite3_rtree_geometry_xGeom)(sqlite3_rtree_geometry_ptr p, int nCoord, sqlite3_rtree_dbl_array_ptr aCoord, C_int_ptr pRes);

struct DECLSPEC_DRECORD sqlite3_rtree_query_info
{
public:
	void *pContext;
	int nParam;
	sqlite3_rtree_dbl_array *aParam;
	void *pUser;
	void __fastcall (*xDelUser)(void * pUser);
	sqlite3_rtree_dbl_array *aCoord;
	unsigned *anQueue;
	int nCoord;
	int iLevel;
	int mxLevel;
	__int64 iRowId;
	double rParentScore;
	int eParentWithin;
	int eWithin;
	double rScore;
};


typedef sqlite3_rtree_query_info *sqlite3_rtree_query_info_ptr;

typedef int __fastcall (*sqlite3_rtree_query_xQueryFunc)(sqlite3_rtree_query_info_ptr p);

typedef void __fastcall (*sqlite3_rtree_query_xDestructor)(void * pCtx);

typedef sqlite3expert *sqlite3expert_ptr;

typedef sqlite3_session *sqlite3_session_ptr;

typedef sqlite3_session_ptr *sqlite3_session_ptr_ptr;

typedef sqlite3_changeset_iter *sqlite3_changeset_iter_ptr;

typedef sqlite3_changeset_iter_ptr *sqlite3_changeset_iter_ptr_ptr;

typedef int __fastcall (*sqlite3session_xFilter)(void * pCtx, const char * zTab);

typedef int __fastcall (*sqlite3session_xConflict)(void * pCtx, int eConflict, sqlite3_changeset_iter_ptr pIter);

typedef sqlite3_changegroup *sqlite3_changegroup_ptr;

typedef sqlite3_changegroup_ptr *sqlite3_changegroup_ptr_ptr;

typedef System::StaticArray<sqlite3_changegroup_ptr, 536870911> sqlite3_changegroup_ptr_array;

typedef sqlite3_changegroup_ptr_array *sqlite3_changegroup_ptr_array_ptr;

typedef sqlite3_rebaser *sqlite3_rebaser_ptr;

typedef sqlite3_rebaser_ptr *sqlite3_rebaser_ptr_ptr;

typedef int __fastcall (*sqlite3session_strm_xInput)(void * pIn, void * pData, C_int_ptr pnData);

typedef int __fastcall (*sqlite3session_strm_xOutput)(void * pOut, const void * pData, int nData);

typedef void __fastcall (*sqlite3_carray_bind_xDel)(void * p);

typedef int __fastcall (*sqlite3_db_dump_callback)(const char * zSql, void * pArg);

struct DECLSPEC_DRECORD Hash
{
public:
	unsigned htsize;
	unsigned Count;
	void *First;
	void *ht;
};


typedef __int64 i64;

typedef unsigned __int64 u64;

typedef unsigned u32;

typedef System::Word u16;

typedef char u8;

typedef unsigned Pgno;

struct DECLSPEC_DRECORD busyHandler
{
public:
	int __fastcall (*xBusyHandler)(void * a, int b);
	void *pBusyArg;
	int nBusy;
};


struct DECLSPEC_DRECORD DB
{
public:
	char *zDbSName;
	void *pBt;
	char safety_level;
	char bSyncSet;
	void *pSchema;
};


typedef LookasideSlot *LookasideSlot_ptr;

struct DECLSPEC_DRECORD LookasideSlot
{
public:
	LookasideSlot *pNext;
};


struct DECLSPEC_DRECORD Lookaside
{
public:
	unsigned bDisable;
	System::Word sz;
	System::Word szTrue;
	char bMalloced;
	unsigned nSlot;
	System::StaticArray<unsigned, 3> anStat;
	LookasideSlot *pInit;
	LookasideSlot *pFree;
	LookasideSlot *pSmallInit;
	LookasideSlot *pSmallFree;
	void *pMiddle;
	void *pStart;
	void *pEnd;
};


typedef System::StaticArray<void *, 23> FuncDefHash;

typedef int __fastcall (*sqlite3_xauth)(void * a1, int a2, const char * a3, const char * a4, const char * a5, const char * a6);

struct DECLSPEC_DRECORD sqlite3_int
{
	
private:
	struct DECLSPEC_DRECORD _sqlite3_int__1
	{
	public:
		unsigned newTnum;
		char iDb;
		char Busy;
		System::Word BitField;
		C_char_ptr_array *azInit;
	};
	
	
	struct DECLSPEC_DRECORD _sqlite3_int__2
	{
		
	public:
		union
		{
			struct 
			{
				int __fastcall (*xV2)(unsigned p1, void * p2, void * p3, void * p4);
			};
			struct 
			{
				void __fastcall (*legacy)(void * p1, const char * p2);
			};
			
		};
	};
	
	
	struct DECLSPEC_DRECORD _sqlite3_int__3
	{
		
	public:
		union
		{
			struct 
			{
				double notUsed1;
			};
			struct 
			{
				int IsInterrupted;
			};
			
		};
	};
	
	
	
public:
	void *pVfs;
	void *pVdbe;
	void *pDfltColl;
	sqlite3_mutex *Mutex;
	void *ADB;
	int nDb;
	unsigned mDbFlags;
	unsigned __int64 Flags;
	__int64 lastRowId;
	__int64 szMmap;
	unsigned nSchemaLock;
	unsigned OpenFlags;
	int ErrCode;
	int ErrMask;
	int iSysErrno;
	unsigned dbOptFlags;
	char Enc;
	char autoCommit;
	char temp_store;
	char mallocFailed;
	char bBenignMalloc;
	char dfltLockMode;
	System::Int8 nextAutovac;
	char suppressErr;
	char vtabOnConflict;
	char isTransactionSavepoint;
	char mTrace;
	char noSharedCache;
	char nSqlExec;
	int nextPagesize;
	unsigned Magic;
	int nChange;
	int nTotalChange;
	System::StaticArray<int, 12> aLimit;
	int nMaxSorterMmap;
	_sqlite3_int__1 Init;
	int nVdbeActive;
	int nVdbeRead;
	int nVdbeWrite;
	int nVdbeExec;
	int nVDestroy;
	int nExtension;
	void *AExtension;
	_sqlite3_int__2 trace;
	void *pTraceArg;
	TSQLite3_Profile_Callback xProfile;
	void *pProfileArg;
	void *pCommitArg;
	TSQLite3_Commit_Callback xCommitCallback;
	void *pRollbackArg;
	TSQLite3_Rollback_Callback xRollbackCallback;
	void *pUpdateArg;
	sqlite3_update_hook_callback xUpdateCallback;
	void *pParse;
	void *pPreUpdateArg;
	sqlite3_preupdate_hook_callback xPreUpdateCallback;
	void *pPreUpdate;
	sqlite3_wal_hook_callback xWalCallback;
	void *pWalArg;
	TSQLite3_Collation_Needed_Callback xCollNeeded;
	TSQLite3_Collation_Needed16_Callback xCollNeeded16;
	void *pCollNeededArg;
	sqlite3_value *pErr;
	_sqlite3_int__3 u1;
	Lookaside Lookaside;
	sqlite3_xauth xAuth;
	void *pAuthArg;
	TSQLite3_Progress_Callback xProgress;
	void *pProgressArg;
	int nProgressOps;
	int nVTrans;
	Hash aModule;
	void *pVtabCtx;
	void *aVTrans;
	void *pDisconnect;
	Hash aFunc;
	Hash aCollSeq;
	busyHandler busyHandler;
	System::StaticArray<DB, 2> aDbStatic;
	void *pSavepoint;
	int nAnalysisLimit;
	int BusyTimeout;
};


typedef sqlite3_int *sqlite3_int_ptr;

#pragma pack(push,4)
class PASCALIMPLEMENTATION ESQLite3 : public System::Sysutils::Exception
{
	typedef System::Sysutils::Exception inherited;
	
private:
	int FErrorCode;
	System::UnicodeString FErrorMessage;
	
public:
	__fastcall ESQLite3(const int ErrorCode, const System::UnicodeString ErrorMessage)/* overload */;
	__fastcall ESQLite3(const int ErrorCode)/* overload */;
	__fastcall ESQLite3(const System::UnicodeString ErrorMessage)/* overload */;
	__property int ErrorCode = {read=FErrorCode, nodefault};
	__property System::UnicodeString ErrorMessage = {read=FErrorMessage};
public:
	/* Exception.CreateFmt */ inline __fastcall ESQLite3(const System::UnicodeString Msg, const System::TVarRec *Args, const int Args_High) : System::Sysutils::Exception(Msg, Args, Args_High) { }
	/* Exception.CreateRes */ inline __fastcall ESQLite3(NativeUInt Ident)/* overload */ : System::Sysutils::Exception(Ident) { }
	/* Exception.CreateRes */ inline __fastcall ESQLite3(System::PResStringRec ResStringRec)/* overload */ : System::Sysutils::Exception(ResStringRec) { }
	/* Exception.CreateResFmt */ inline __fastcall ESQLite3(NativeUInt Ident, const System::TVarRec *Args, const int Args_High)/* overload */ : System::Sysutils::Exception(Ident, Args, Args_High) { }
	/* Exception.CreateResFmt */ inline __fastcall ESQLite3(System::PResStringRec ResStringRec, const System::TVarRec *Args, const int Args_High)/* overload */ : System::Sysutils::Exception(ResStringRec, Args, Args_High) { }
	/* Exception.CreateHelp */ inline __fastcall ESQLite3(const System::UnicodeString Msg, int AHelpContext) : System::Sysutils::Exception(Msg, AHelpContext) { }
	/* Exception.CreateFmtHelp */ inline __fastcall ESQLite3(const System::UnicodeString Msg, const System::TVarRec *Args, const int Args_High, int AHelpContext) : System::Sysutils::Exception(Msg, Args, Args_High, AHelpContext) { }
	/* Exception.CreateResHelp */ inline __fastcall ESQLite3(NativeUInt Ident, int AHelpContext)/* overload */ : System::Sysutils::Exception(Ident, AHelpContext) { }
	/* Exception.CreateResHelp */ inline __fastcall ESQLite3(System::PResStringRec ResStringRec, int AHelpContext)/* overload */ : System::Sysutils::Exception(ResStringRec, AHelpContext) { }
	/* Exception.CreateResFmtHelp */ inline __fastcall ESQLite3(System::PResStringRec ResStringRec, const System::TVarRec *Args, const int Args_High, int AHelpContext)/* overload */ : System::Sysutils::Exception(ResStringRec, Args, Args_High, AHelpContext) { }
	/* Exception.CreateResFmtHelp */ inline __fastcall ESQLite3(NativeUInt Ident, const System::TVarRec *Args, const int Args_High, int AHelpContext)/* overload */ : System::Sysutils::Exception(Ident, Args, Args_High, AHelpContext) { }
	/* Exception.Destroy */ inline __fastcall virtual ~ESQLite3() { }
	
};

#pragma pack(pop)

typedef double TDIJulianDate;

enum DECLSPEC_DENUM TDISQLite3Affinity : unsigned char { afInteger, afText, afNone, afReal, afNumeric };

enum DECLSPEC_DENUM TDISQLite3DatabaseType : unsigned char { dtMain, dtTemp, dtAttached };

enum DECLSPEC_DENUM TDISQLite3Encoding : unsigned char { encUnknown, encUtf8, encUtf16, encUtf16le, encUtf16be };

//-- var, const, procedure ---------------------------------------------------
extern DELPHI_PACKAGE System::ResourceString _RSQLite3Error;
#define Disqlite3api_RSQLite3Error System::LoadResourceString(&Disqlite3api::_RSQLite3Error)
extern DELPHI_PACKAGE System::ResourceString _RSQLite3ErrorMsg;
#define Disqlite3api_RSQLite3ErrorMsg System::LoadResourceString(&Disqlite3api::_RSQLite3ErrorMsg)
static const System::WideChar SQLITE3_IDENTIFIER_QUOTE_CHAR = (System::WideChar)(0x22);
static const System::WideChar SQLITE3_STRING_QUOTE_CHAR = (System::WideChar)(0x27);
static const System::Int8 SQLITE_OK = System::Int8(0x0);
static const System::Int8 SQLITE_ERROR = System::Int8(0x1);
static const System::Int8 SQLITE_INTERNAL = System::Int8(0x2);
static const System::Int8 SQLITE_PERM = System::Int8(0x3);
static const System::Int8 SQLITE_ABORT = System::Int8(0x4);
static const System::Int8 SQLITE_BUSY = System::Int8(0x5);
static const System::Int8 SQLITE_LOCKED = System::Int8(0x6);
static const System::Int8 SQLITE_NOMEM = System::Int8(0x7);
static const System::Int8 SQLITE_READONLY = System::Int8(0x8);
static const System::Int8 SQLITE_INTERRUPT = System::Int8(0x9);
static const System::Int8 SQLITE_IOERR = System::Int8(0xa);
static const System::Int8 SQLITE_CORRUPT = System::Int8(0xb);
static const System::Int8 SQLITE_NOTFOUND = System::Int8(0xc);
static const System::Int8 SQLITE_FULL = System::Int8(0xd);
static const System::Int8 SQLITE_CANTOPEN = System::Int8(0xe);
static const System::Int8 SQLITE_PROTOCOL = System::Int8(0xf);
static const System::Int8 SQLITE_EMPTY = System::Int8(0x10);
static const System::Int8 SQLITE_SCHEMA = System::Int8(0x11);
static const System::Int8 SQLITE_TOOBIG = System::Int8(0x12);
static const System::Int8 SQLITE_CONSTRAINT = System::Int8(0x13);
static const System::Int8 SQLITE_MISMATCH = System::Int8(0x14);
static const System::Int8 SQLITE_MISUSE = System::Int8(0x15);
static const System::Int8 SQLITE_NOLFS = System::Int8(0x16);
static const System::Int8 SQLITE_AUTH = System::Int8(0x17);
static const System::Int8 SQLITE_FORMAT = System::Int8(0x18);
static const System::Int8 SQLITE_RANGE = System::Int8(0x19);
static const System::Int8 SQLITE_NOTADB = System::Int8(0x1a);
static const System::Int8 SQLITE_NOTICE = System::Int8(0x1b);
static const System::Int8 SQLITE_WARNING = System::Int8(0x1c);
static const System::Int8 SQLITE_ROW = System::Int8(0x64);
static const System::Int8 SQLITE_DONE = System::Int8(0x65);
static const System::Word SQLITE_ERROR_MISSING_COLLSEQ = System::Word(0x101);
static const System::Word SQLITE_ERROR_RETRY = System::Word(0x201);
static const System::Word SQLITE_ERROR_SNAPSHOT = System::Word(0x301);
static const System::Word SQLITE_IOERR_READ = System::Word(0x10a);
static const System::Word SQLITE_IOERR_SHORT_READ = System::Word(0x20a);
static const System::Word SQLITE_IOERR_WRITE = System::Word(0x30a);
static const System::Word SQLITE_IOERR_FSYNC = System::Word(0x40a);
static const System::Word SQLITE_IOERR_DIR_FSYNC = System::Word(0x50a);
static const System::Word SQLITE_IOERR_TRUNCATE = System::Word(0x60a);
static const System::Word SQLITE_IOERR_FSTAT = System::Word(0x70a);
static const System::Word SQLITE_IOERR_UNLOCK = System::Word(0x80a);
static const System::Word SQLITE_IOERR_RDLOCK = System::Word(0x90a);
static const System::Word SQLITE_IOERR_DELETE = System::Word(0xa0a);
static const System::Word SQLITE_IOERR_BLOCKED = System::Word(0xb0a);
static const System::Word SQLITE_IOERR_NOMEM = System::Word(0xc0a);
static const System::Word SQLITE_IOERR_ACCESS = System::Word(0xd0a);
static const System::Word SQLITE_IOERR_CHECKRESERVEDLOCK = System::Word(0xe0a);
static const System::Word SQLITE_IOERR_LOCK = System::Word(0xf0a);
static const System::Word SQLITE_IOERR_CLOSE = System::Word(0x100a);
static const System::Word SQLITE_IOERR_DIR_CLOSE = System::Word(0x110a);
static const System::Word SQLITE_IOERR_SHMOPEN = System::Word(0x120a);
static const System::Word SQLITE_IOERR_SHMSIZE = System::Word(0x130a);
static const System::Word SQLITE_IOERR_SHMLOCK = System::Word(0x140a);
static const System::Word SQLITE_IOERR_SHMMAP = System::Word(0x150a);
static const System::Word SQLITE_IOERR_SEEK = System::Word(0x160a);
static const System::Word SQLITE_IOERR_DELETE_NOENT = System::Word(0x170a);
static const System::Word SQLITE_IOERR_MMAP = System::Word(0x180a);
static const System::Word SQLITE_IOERR_GETTEMPPATH = System::Word(0x190a);
static const System::Word SQLITE_IOERR_CONVPATH = System::Word(0x1a0a);
static const System::Word SQLITE_IOERR_VNODE = System::Word(0x1b0a);
static const System::Word SQLITE_IOERR_AUTH = System::Word(0x1c0a);
static const System::Word SQLITE_IOERR_BEGIN_ATOMIC = System::Word(0x1d0a);
static const System::Word SQLITE_IOERR_COMMIT_ATOMIC = System::Word(0x1e0a);
static const System::Word SQLITE_IOERR_ROLLBACK_ATOMIC = System::Word(0x1f0a);
static const System::Word SQLITE_IOERR_DATA = System::Word(0x200a);
static const System::Word SQLITE_LOCKED_SHAREDCACHE = System::Word(0x106);
static const System::Word SQLITE_LOCKED_VTAB = System::Word(0x206);
static const System::Word SQLITE_BUSY_RECOVERY = System::Word(0x105);
static const System::Word SQLITE_BUSY_SNAPSHOT = System::Word(0x205);
static const System::Word SQLITE_BUSY_TIMEOUT = System::Word(0x305);
static const System::Word SQLITE_CANTOPEN_NOTEMPDIR = System::Word(0x10e);
static const System::Word SQLITE_CANTOPEN_ISDIR = System::Word(0x20e);
static const System::Word SQLITE_CANTOPEN_FULLPATH = System::Word(0x30e);
static const System::Word SQLITE_CANTOPEN_CONVPATH = System::Word(0x40e);
static const System::Word SQLITE_CANTOPEN_DIRTYWAL = System::Word(0x50e);
static const System::Word SQLITE_CANTOPEN_SYMLINK = System::Word(0x60e);
static const System::Word SQLITE_CORRUPT_VTAB = System::Word(0x10b);
static const System::Word SQLITE_CORRUPT_SEQUENCE = System::Word(0x20b);
static const System::Word SQLITE_CORRUPT_INDEX = System::Word(0x30b);
static const System::Word SQLITE_READONLY_RECOVERY = System::Word(0x108);
static const System::Word SQLITE_READONLY_CANTLOCK = System::Word(0x208);
static const System::Word SQLITE_READONLY_ROLLBACK = System::Word(0x308);
static const System::Word SQLITE_READONLY_DBMOVED = System::Word(0x408);
static const System::Word SQLITE_READONLY_CANTINIT = System::Word(0x508);
static const System::Word SQLITE_READONLY_DIRECTORY = System::Word(0x608);
static const System::Word SQLITE_ABORT_ROLLBACK = System::Word(0x204);
static const System::Word SQLITE_CONSTRAINT_CHECK = System::Word(0x113);
static const System::Word SQLITE_CONSTRAINT_COMMITHOOK = System::Word(0x213);
static const System::Word SQLITE_CONSTRAINT_FOREIGNKEY = System::Word(0x313);
static const System::Word SQLITE_CONSTRAINT_FUNCTION = System::Word(0x413);
static const System::Word SQLITE_CONSTRAINT_NOTNULL = System::Word(0x513);
static const System::Word SQLITE_CONSTRAINT_PRIMARYKEY = System::Word(0x613);
static const System::Word SQLITE_CONSTRAINT_TRIGGER = System::Word(0x713);
static const System::Word SQLITE_CONSTRAINT_UNIQUE = System::Word(0x813);
static const System::Word SQLITE_CONSTRAINT_VTAB = System::Word(0x913);
static const System::Word SQLITE_CONSTRAINT_ROWID = System::Word(0xa13);
static const System::Word SQLITE_CONSTRAINT_PINNED = System::Word(0xb13);
static const System::Word SQLITE_NOTICE_RECOVER_WAL = System::Word(0x11b);
static const System::Word SQLITE_NOTICE_RECOVER_ROLLBACK = System::Word(0x21b);
static const System::Word SQLITE_WARNING_AUTOINDEX = System::Word(0x11c);
static const System::Word SQLITE_AUTH_USER = System::Word(0x117);
static const System::Word SQLITE_OK_LOAD_PERMANENTLY = System::Word(0x100);
static const System::Word SQLITE_OK_SYMLINK = System::Word(0x200);
static const System::Int8 SQLITE_OPEN_READONLY = System::Int8(0x1);
static const System::Int8 SQLITE_OPEN_READWRITE = System::Int8(0x2);
static const System::Int8 SQLITE_OPEN_CREATE = System::Int8(0x4);
static const System::Int8 SQLITE_OPEN_DELETEONCLOSE = System::Int8(0x8);
static const System::Int8 SQLITE_OPEN_EXCLUSIVE = System::Int8(0x10);
static const System::Int8 SQLITE_OPEN_AUTOPROXY = System::Int8(0x20);
static const System::Int8 SQLITE_OPEN_URI = System::Int8(0x40);
static const System::Byte SQLITE_OPEN_MEMORY = System::Byte(0x80);
static const System::Word SQLITE_OPEN_MAIN_DB = System::Word(0x100);
static const System::Word SQLITE_OPEN_TEMP_DB = System::Word(0x200);
static const System::Word SQLITE_OPEN_TRANSIENT_DB = System::Word(0x400);
static const System::Word SQLITE_OPEN_MAIN_JOURNAL = System::Word(0x800);
static const System::Word SQLITE_OPEN_TEMP_JOURNAL = System::Word(0x1000);
static const System::Word SQLITE_OPEN_SUBJOURNAL = System::Word(0x2000);
static const System::Word SQLITE_OPEN_SUPER_JOURNAL = System::Word(0x4000);
static const System::Word SQLITE_OPEN_NOMUTEX = System::Word(0x8000);
static const int SQLITE_OPEN_FULLMUTEX = int(0x10000);
static const int SQLITE_OPEN_SHAREDCACHE = int(0x20000);
static const int SQLITE_OPEN_PRIVATECACHE = int(0x40000);
static const int SQLITE_OPEN_WAL = int(0x80000);
static const int SQLITE_OPEN_NOFOLLOW = int(0x1000000);
static const System::Word SQLITE_OPEN_MASTER_JOURNAL _DEPRECATED_ATTRIBUTE1("Use SQLITE_OPEN_SUPER_JOURNAL instead")  = System::Word(0x4000);
static const System::Int8 SQLITE_IOCAP_ATOMIC = System::Int8(0x1);
static const System::Int8 SQLITE_IOCAP_ATOMIC512 = System::Int8(0x2);
static const System::Int8 SQLITE_IOCAP_ATOMIC1K = System::Int8(0x4);
static const System::Int8 SQLITE_IOCAP_ATOMIC2K = System::Int8(0x8);
static const System::Int8 SQLITE_IOCAP_ATOMIC4K = System::Int8(0x10);
static const System::Int8 SQLITE_IOCAP_ATOMIC8K = System::Int8(0x20);
static const System::Int8 SQLITE_IOCAP_ATOMIC16K = System::Int8(0x40);
static const System::Byte SQLITE_IOCAP_ATOMIC32K = System::Byte(0x80);
static const System::Word SQLITE_IOCAP_ATOMIC64K = System::Word(0x100);
static const System::Word SQLITE_IOCAP_SAFE_APPEND = System::Word(0x200);
static const System::Word SQLITE_IOCAP_SEQUENTIAL = System::Word(0x400);
static const System::Word SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN = System::Word(0x800);
static const System::Word SQLITE_IOCAP_POWERSAFE_OVERWRITE = System::Word(0x1000);
static const System::Word SQLITE_IOCAP_IMMUTABLE = System::Word(0x2000);
static const System::Word SQLITE_IOCAP_BATCH_ATOMIC = System::Word(0x4000);
static const System::Int8 SQLITE_LOCK_NONE = System::Int8(0x0);
static const System::Int8 SQLITE_LOCK_SHARED = System::Int8(0x1);
static const System::Int8 SQLITE_LOCK_RESERVED = System::Int8(0x2);
static const System::Int8 SQLITE_LOCK_PENDING = System::Int8(0x3);
static const System::Int8 SQLITE_LOCK_EXCLUSIVE = System::Int8(0x4);
static const System::Int8 SQLITE_SYNC_NORMAL = System::Int8(0x2);
static const System::Int8 SQLITE_SYNC_FULL = System::Int8(0x3);
static const System::Int8 SQLITE_SYNC_DATAONLY = System::Int8(0x10);
static const System::Int8 SQLITE_FCNTL_LOCKSTATE = System::Int8(0x1);
static const System::Int8 SQLITE_FCNTL_GET_LOCKPROXYFILE = System::Int8(0x2);
static const System::Int8 SQLITE_FCNTL_SET_LOCKPROXYFILE = System::Int8(0x3);
static const System::Int8 SQLITE_FCNTL_LAST_ERRNO = System::Int8(0x4);
static const System::Int8 SQLITE_FCNTL_SIZE_HINT = System::Int8(0x5);
static const System::Int8 SQLITE_FCNTL_CHUNK_SIZE = System::Int8(0x6);
static const System::Int8 SQLITE_FCNTL_FILE_POINTER = System::Int8(0x7);
static const System::Int8 SQLITE_FCNTL_SYNC_OMITTED = System::Int8(0x8);
static const System::Int8 SQLITE_FCNTL_WIN32_AV_RETRY = System::Int8(0x9);
static const System::Int8 SQLITE_FCNTL_PERSIST_WAL = System::Int8(0xa);
static const System::Int8 SQLITE_FCNTL_OVERWRITE = System::Int8(0xb);
static const System::Int8 SQLITE_FCNTL_VFSNAME = System::Int8(0xc);
static const System::Int8 SQLITE_FCNTL_POWERSAFE_OVERWRITE = System::Int8(0xd);
static const System::Int8 SQLITE_FCNTL_PRAGMA = System::Int8(0xe);
static const System::Int8 SQLITE_FCNTL_BUSYHANDLER = System::Int8(0xf);
static const System::Int8 SQLITE_FCNTL_TEMPFILENAME = System::Int8(0x10);
static const System::Int8 SQLITE_FCNTL_MMAP_SIZE = System::Int8(0x12);
static const System::Int8 SQLITE_FCNTL_TRACE = System::Int8(0x13);
static const System::Int8 SQLITE_FCNTL_HAS_MOVED = System::Int8(0x14);
static const System::Int8 SQLITE_FCNTL_SYNC = System::Int8(0x15);
static const System::Int8 SQLITE_FCNTL_COMMIT_PHASETWO = System::Int8(0x16);
static const System::Int8 SQLITE_FCNTL_WIN32_SET_HANDLE = System::Int8(0x17);
static const System::Int8 SQLITE_FCNTL_WAL_BLOCK = System::Int8(0x18);
static const System::Int8 SQLITE_FCNTL_ZIPVFS = System::Int8(0x19);
static const System::Int8 SQLITE_FCNTL_RBU = System::Int8(0x1a);
static const System::Int8 SQLITE_FCNTL_VFS_POINTER = System::Int8(0x1b);
static const System::Int8 SQLITE_FCNTL_JOURNAL_POINTER = System::Int8(0x1c);
static const System::Int8 SQLITE_FCNTL_WIN32_GET_HANDLE = System::Int8(0x1d);
static const System::Int8 SQLITE_FCNTL_PDB = System::Int8(0x1e);
static const System::Int8 SQLITE_FCNTL_BEGIN_ATOMIC_WRITE = System::Int8(0x1f);
static const System::Int8 SQLITE_FCNTL_COMMIT_ATOMIC_WRITE = System::Int8(0x20);
static const System::Int8 SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE = System::Int8(0x21);
static const System::Int8 SQLITE_FCNTL_LOCK_TIMEOUT = System::Int8(0x22);
static const System::Int8 SQLITE_FCNTL_DATA_VERSION = System::Int8(0x23);
static const System::Int8 SQLITE_FCNTL_SIZE_LIMIT = System::Int8(0x24);
static const System::Int8 SQLITE_FCNTL_CKPT_DONE = System::Int8(0x25);
static const System::Int8 SQLITE_FCNTL_RESERVE_BYTES = System::Int8(0x26);
static const System::Int8 SQLITE_FCNTL_CKPT_START = System::Int8(0x27);
static const System::Int8 SQLITE_FCNTL_EXTERNAL_READER = System::Int8(0x28);
static const System::Int8 SQLITE_FCNTL_CKSM_FILE = System::Int8(0x29);
static const System::Int8 SQLITE_GET_LOCKPROXYFILE _DEPRECATED_ATTRIBUTE1("Use SQLITE_FCNTL_GET_LOCKPROXYFILE instead")  = System::Int8(0x2);
static const System::Int8 SQLITE_SET_LOCKPROXYFILE _DEPRECATED_ATTRIBUTE1("Use SQLITE_FCNTL_SET_LOCKPROXYFILE instead")  = System::Int8(0x3);
static const System::Int8 SQLITE_LAST_ERRNO _DEPRECATED_ATTRIBUTE1("Use SQLITE_FCNTL_LAST_ERRNO instead")  = System::Int8(0x4);
static const System::Int8 SQLITE_ACCESS_EXISTS = System::Int8(0x0);
static const System::Int8 SQLITE_ACCESS_READWRITE = System::Int8(0x1);
static const System::Int8 SQLITE_ACCESS_READ = System::Int8(0x2);
static const System::Int8 SQLITE_SHM_UNLOCK = System::Int8(0x1);
static const System::Int8 SQLITE_SHM_LOCK = System::Int8(0x2);
static const System::Int8 SQLITE_SHM_SHARED = System::Int8(0x4);
static const System::Int8 SQLITE_SHM_EXCLUSIVE = System::Int8(0x8);
static const System::Int8 SQLITE_SHM_NLOCK = System::Int8(0x8);
static const System::Int8 SQLITE_CONFIG_SINGLETHREAD = System::Int8(0x1);
static const System::Int8 SQLITE_CONFIG_MULTITHREAD = System::Int8(0x2);
static const System::Int8 SQLITE_CONFIG_SERIALIZED = System::Int8(0x3);
static const System::Int8 SQLITE_CONFIG_MALLOC = System::Int8(0x4);
static const System::Int8 SQLITE_CONFIG_GETMALLOC = System::Int8(0x5);
static const System::Int8 SQLITE_CONFIG_SCRATCH = System::Int8(0x6);
static const System::Int8 SQLITE_CONFIG_PAGECACHE = System::Int8(0x7);
static const System::Int8 SQLITE_CONFIG_HEAP = System::Int8(0x8);
static const System::Int8 SQLITE_CONFIG_MEMSTATUS = System::Int8(0x9);
static const System::Int8 SQLITE_CONFIG_MUTEX = System::Int8(0xa);
static const System::Int8 SQLITE_CONFIG_GETMUTEX = System::Int8(0xb);
static const System::Int8 SQLITE_CONFIG_LOOKASIDE = System::Int8(0xd);
static const System::Int8 SQLITE_CONFIG_PCACHE _DEPRECATED_ATTRIBUTE0  = System::Int8(0xe);
static const System::Int8 SQLITE_CONFIG_GETPCACHE _DEPRECATED_ATTRIBUTE0  = System::Int8(0xf);
static const System::Int8 SQLITE_CONFIG_LOG = System::Int8(0x10);
static const System::Int8 SQLITE_CONFIG_URI = System::Int8(0x11);
static const System::Int8 SQLITE_CONFIG_PCACHE2 = System::Int8(0x12);
static const System::Int8 SQLITE_CONFIG_GETPCACHE2 = System::Int8(0x13);
static const System::Int8 SQLITE_CONFIG_COVERING_INDEX_SCAN = System::Int8(0x14);
static const System::Int8 SQLITE_CONFIG_SQLLOG = System::Int8(0x15);
static const System::Int8 SQLITE_CONFIG_MMAP_SIZE = System::Int8(0x16);
static const System::Int8 SQLITE_CONFIG_WIN32_HEAPSIZE = System::Int8(0x17);
static const System::Int8 SQLITE_CONFIG_PCACHE_HDRSZ = System::Int8(0x18);
static const System::Int8 SQLITE_CONFIG_PMASZ = System::Int8(0x19);
static const System::Int8 SQLITE_CONFIG_STMTJRNL_SPILL = System::Int8(0x1a);
static const System::Int8 SQLITE_CONFIG_SMALL_MALLOC = System::Int8(0x1b);
static const System::Int8 SQLITE_CONFIG_SORTERREF_SIZE = System::Int8(0x1c);
static const System::Int8 SQLITE_CONFIG_MEMDB_MAXSIZE = System::Int8(0x1d);
static const System::Word SQLITE_DBCONFIG_MAINDBNAME = System::Word(0x3e8);
static const System::Word SQLITE_DBCONFIG_LOOKASIDE = System::Word(0x3e9);
static const System::Word SQLITE_DBCONFIG_ENABLE_FKEY = System::Word(0x3ea);
static const System::Word SQLITE_DBCONFIG_ENABLE_TRIGGER = System::Word(0x3eb);
static const System::Word SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER = System::Word(0x3ec);
static const System::Word SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION = System::Word(0x3ed);
static const System::Word SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE = System::Word(0x3ee);
static const System::Word SQLITE_DBCONFIG_ENABLE_QPSG = System::Word(0x3ef);
static const System::Word SQLITE_DBCONFIG_TRIGGER_EQP = System::Word(0x3f0);
static const System::Word SQLITE_DBCONFIG_RESET_DATABASE = System::Word(0x3f1);
static const System::Word SQLITE_DBCONFIG_DEFENSIVE = System::Word(0x3f2);
static const System::Word SQLITE_DBCONFIG_WRITABLE_SCHEMA = System::Word(0x3f3);
static const System::Word SQLITE_DBCONFIG_LEGACY_ALTER_TABLE = System::Word(0x3f4);
static const System::Word SQLITE_DBCONFIG_DQS_DML = System::Word(0x3f5);
static const System::Word SQLITE_DBCONFIG_DQS_DDL = System::Word(0x3f6);
static const System::Word SQLITE_DBCONFIG_ENABLE_VIEW = System::Word(0x3f7);
static const System::Word SQLITE_DBCONFIG_LEGACY_FILE_FORMAT = System::Word(0x3f8);
static const System::Word SQLITE_DBCONFIG_TRUSTED_SCHEMA = System::Word(0x3f9);
static const System::Word SQLITE_DBCONFIG_MAX = System::Word(0x3f9);
static const System::Int8 SQLITE_CREATE_INDEX = System::Int8(0x1);
static const System::Int8 SQLITE_CREATE_TABLE = System::Int8(0x2);
static const System::Int8 SQLITE_CREATE_TEMP_INDEX = System::Int8(0x3);
static const System::Int8 SQLITE_CREATE_TEMP_TABLE = System::Int8(0x4);
static const System::Int8 SQLITE_CREATE_TEMP_TRIGGER = System::Int8(0x5);
static const System::Int8 SQLITE_CREATE_TEMP_VIEW = System::Int8(0x6);
static const System::Int8 SQLITE_CREATE_TRIGGER = System::Int8(0x7);
static const System::Int8 SQLITE_CREATE_VIEW = System::Int8(0x8);
static const System::Int8 SQLITE_DELETE = System::Int8(0x9);
static const System::Int8 SQLITE_DROP_INDEX = System::Int8(0xa);
static const System::Int8 SQLITE_DROP_TABLE = System::Int8(0xb);
static const System::Int8 SQLITE_DROP_TEMP_INDEX = System::Int8(0xc);
static const System::Int8 SQLITE_DROP_TEMP_TABLE = System::Int8(0xd);
static const System::Int8 SQLITE_DROP_TEMP_TRIGGER = System::Int8(0xe);
static const System::Int8 SQLITE_DROP_TEMP_VIEW = System::Int8(0xf);
static const System::Int8 SQLITE_DROP_TRIGGER = System::Int8(0x10);
static const System::Int8 SQLITE_DROP_VIEW = System::Int8(0x11);
static const System::Int8 SQLITE_INSERT = System::Int8(0x12);
static const System::Int8 SQLITE_PRAGMA = System::Int8(0x13);
static const System::Int8 SQLITE_READ = System::Int8(0x14);
static const System::Int8 SQLITE_SELECT = System::Int8(0x15);
static const System::Int8 SQLITE_TRANSACTION = System::Int8(0x16);
static const System::Int8 SQLITE_UPDATE = System::Int8(0x17);
static const System::Int8 SQLITE_ATTACH = System::Int8(0x18);
static const System::Int8 SQLITE_DETACH = System::Int8(0x19);
static const System::Int8 SQLITE_ALTER_TABLE = System::Int8(0x1a);
static const System::Int8 SQLITE_REINDEX = System::Int8(0x1b);
static const System::Int8 SQLITE_ANALYZE = System::Int8(0x1c);
static const System::Int8 SQLITE_CREATE_VTABLE = System::Int8(0x1d);
static const System::Int8 SQLITE_DROP_VTABLE = System::Int8(0x1e);
static const System::Int8 SQLITE_FUNCTION = System::Int8(0x1f);
static const System::Int8 SQLITE_SAVEPOINT = System::Int8(0x20);
static const System::Int8 SQLITE_COPY = System::Int8(0x0);
static const System::Int8 SQLITE_RECURSIVE = System::Int8(0x21);
static const System::Int8 SQLITE_DENY = System::Int8(0x1);
static const System::Int8 SQLITE_IGNORE = System::Int8(0x2);
static const System::Int8 SQLITE_TRACE_STMT = System::Int8(0x1);
static const System::Int8 SQLITE_TRACE_PROFILE = System::Int8(0x2);
static const System::Int8 SQLITE_TRACE_ROW = System::Int8(0x4);
static const System::Int8 SQLITE_TRACE_CLOSE = System::Int8(0x8);
static const System::Int8 SQLITE_LIMIT_LENGTH = System::Int8(0x0);
static const System::Int8 SQLITE_LIMIT_SQL_LENGTH = System::Int8(0x1);
static const System::Int8 SQLITE_LIMIT_COLUMN = System::Int8(0x2);
static const System::Int8 SQLITE_LIMIT_EXPR_DEPTH = System::Int8(0x3);
static const System::Int8 SQLITE_LIMIT_COMPOUND_SELECT = System::Int8(0x4);
static const System::Int8 SQLITE_LIMIT_VDBE_OP = System::Int8(0x5);
static const System::Int8 SQLITE_LIMIT_FUNCTION_ARG = System::Int8(0x6);
static const System::Int8 SQLITE_LIMIT_ATTACHED = System::Int8(0x7);
static const System::Int8 SQLITE_LIMIT_LIKE_PATTERN_LENGTH = System::Int8(0x8);
static const System::Int8 SQLITE_LIMIT_VARIABLE_NUMBER = System::Int8(0x9);
static const System::Int8 SQLITE_LIMIT_TRIGGER_DEPTH = System::Int8(0xa);
static const System::Int8 SQLITE_LIMIT_WORKER_THREADS = System::Int8(0xb);
static const System::Int8 SQLITE_PREPARE_PERSISTENT = System::Int8(0x1);
static const System::Int8 SQLITE_PREPARE_NORMALIZE = System::Int8(0x2);
static const System::Int8 SQLITE_PREPARE_NO_VTAB = System::Int8(0x4);
static const System::Int8 SQLITE_INTEGER = System::Int8(0x1);
static const System::Int8 SQLITE_FLOAT = System::Int8(0x2);
static const System::Int8 SQLITE_TEXT = System::Int8(0x3);
static const System::Int8 SQLITE_BLOB = System::Int8(0x4);
static const System::Int8 SQLITE_NULL = System::Int8(0x5);
static const System::Int8 SQLITE3_TEXT = System::Int8(0x3);
static const System::Int8 SQLITE_UTF8 = System::Int8(0x1);
static const System::Int8 SQLITE_UTF16LE = System::Int8(0x2);
static const System::Int8 SQLITE_UTF16BE = System::Int8(0x3);
static const System::Int8 SQLITE_UTF16 = System::Int8(0x4);
static const System::Int8 SQLITE_ANY _DEPRECATED_ATTRIBUTE0  = System::Int8(0x5);
static const System::Int8 SQLITE_UTF16_ALIGNED = System::Int8(0x8);
static const System::Word SQLITE_DETERMINISTIC = System::Word(0x800);
static const int SQLITE_DIRECTONLY = int(0x80000);
static const int SQLITE_SUBTYPE = int(0x100000);
static const int SQLITE_INNOCUOUS = int(0x200000);
extern DELPHI_PACKAGE TSQLite3_Destructor SQLITE_STATIC;
extern DELPHI_PACKAGE TSQLite3_Destructor SQLITE_TRANSIENT;
extern DELPHI_PACKAGE char *sqlite3_temp_directory;
extern DELPHI_PACKAGE char *sqlite3_data_directory;
static const System::Int8 SQLITE_TXN_NONE = System::Int8(0x0);
static const System::Int8 SQLITE_TXN_READ = System::Int8(0x1);
static const System::Int8 SQLITE_TXN_WRITE = System::Int8(0x2);
static const System::Int8 SQLITE_INDEX_SCAN_UNIQUE = System::Int8(0x1);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_EQ = System::Int8(0x2);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_GT = System::Int8(0x4);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_LE = System::Int8(0x8);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_LT = System::Int8(0x10);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_GE = System::Int8(0x20);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_MATCH = System::Int8(0x40);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_LIKE = System::Int8(0x41);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_GLOB = System::Int8(0x42);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_REGEXP = System::Int8(0x43);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_NE = System::Int8(0x44);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_ISNOT = System::Int8(0x45);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_ISNOTNULL = System::Int8(0x46);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_ISNULL = System::Int8(0x47);
static const System::Int8 SQLITE_INDEX_CONSTRAINT_IS = System::Int8(0x48);
static const System::Byte SQLITE_INDEX_CONSTRAINT_FUNCTION = System::Byte(0x96);
static const System::Int8 SQLITE_MUTEX_FAST = System::Int8(0x0);
static const System::Int8 SQLITE_MUTEX_RECURSIVE = System::Int8(0x1);
static const System::Int8 SQLITE_MUTEX_STATIC_MAIN = System::Int8(0x2);
static const System::Int8 SQLITE_MUTEX_STATIC_MEM = System::Int8(0x3);
static const System::Int8 SQLITE_MUTEX_STATIC_MEM2 = System::Int8(0x4);
static const System::Int8 SQLITE_MUTEX_STATIC_OPEN = System::Int8(0x4);
static const System::Int8 SQLITE_MUTEX_STATIC_PRNG = System::Int8(0x5);
static const System::Int8 SQLITE_MUTEX_STATIC_LRU = System::Int8(0x6);
static const System::Int8 SQLITE_MUTEX_STATIC_LRU2 = System::Int8(0x7);
static const System::Int8 SQLITE_MUTEX_STATIC_PMEM = System::Int8(0x7);
static const System::Int8 SQLITE_MUTEX_STATIC_APP1 = System::Int8(0x8);
static const System::Int8 SQLITE_MUTEX_STATIC_APP2 = System::Int8(0x9);
static const System::Int8 SQLITE_MUTEX_STATIC_APP3 = System::Int8(0xa);
static const System::Int8 SQLITE_MUTEX_STATIC_VFS1 = System::Int8(0xb);
static const System::Int8 SQLITE_MUTEX_STATIC_VFS2 = System::Int8(0xc);
static const System::Int8 SQLITE_MUTEX_STATIC_VFS3 = System::Int8(0xd);
static const System::Int8 SQLITE_MUTEX_STATIC_MASTER _DEPRECATED_ATTRIBUTE1("Use SQLITE_MUTEX_STATIC_MAIN instead")  = System::Int8(0x2);
static const System::Int8 SQLITE_TESTCTRL_FIRST = System::Int8(0x5);
static const System::Int8 SQLITE_TESTCTRL_PRNG_SAVE = System::Int8(0x5);
static const System::Int8 SQLITE_TESTCTRL_PRNG_RESTORE = System::Int8(0x6);
static const System::Int8 SQLITE_TESTCTRL_PRNG_RESET = System::Int8(0x7);
static const System::Int8 SQLITE_TESTCTRL_BITVEC_TEST = System::Int8(0x8);
static const System::Int8 SQLITE_TESTCTRL_FAULT_INSTALL = System::Int8(0x9);
static const System::Int8 SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS = System::Int8(0xa);
static const System::Int8 SQLITE_TESTCTRL_PENDING_BYTE = System::Int8(0xb);
static const System::Int8 SQLITE_TESTCTRL_ASSERT = System::Int8(0xc);
static const System::Int8 SQLITE_TESTCTRL_ALWAYS = System::Int8(0xd);
static const System::Int8 SQLITE_TESTCTRL_RESERVE = System::Int8(0xe);
static const System::Int8 SQLITE_TESTCTRL_OPTIMIZATIONS = System::Int8(0xf);
static const System::Int8 SQLITE_TESTCTRL_ISKEYWORD = System::Int8(0x10);
static const System::Int8 SQLITE_TESTCTRL_SCRATCHMALLOC = System::Int8(0x11);
static const System::Int8 SQLITE_TESTCTRL_INTERNAL_FUNCTIONS = System::Int8(0x11);
static const System::Int8 SQLITE_TESTCTRL_LOCALTIME_FAULT = System::Int8(0x12);
static const System::Int8 SQLITE_TESTCTRL_EXPLAIN_STMT = System::Int8(0x13);
static const System::Int8 SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD = System::Int8(0x13);
static const System::Int8 SQLITE_TESTCTRL_NEVER_CORRUPT = System::Int8(0x14);
static const System::Int8 SQLITE_TESTCTRL_VDBE_COVERAGE = System::Int8(0x15);
static const System::Int8 SQLITE_TESTCTRL_BYTEORDER = System::Int8(0x16);
static const System::Int8 SQLITE_TESTCTRL_ISINIT = System::Int8(0x17);
static const System::Int8 SQLITE_TESTCTRL_SORTER_MMAP = System::Int8(0x18);
static const System::Int8 SQLITE_TESTCTRL_IMPOSTER = System::Int8(0x19);
static const System::Int8 SQLITE_TESTCTRL_PARSER_COVERAGE = System::Int8(0x1a);
static const System::Int8 SQLITE_TESTCTRL_RESULT_INTREAL = System::Int8(0x1b);
static const System::Int8 SQLITE_TESTCTRL_PRNG_SEED = System::Int8(0x1c);
static const System::Int8 SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS = System::Int8(0x1d);
static const System::Int8 SQLITE_TESTCTRL_SEEK_COUNT = System::Int8(0x1e);
static const System::Int8 SQLITE_TESTCTRL_TRACEFLAGS = System::Int8(0x1f);
static const System::Int8 SQLITE_TESTCTRL_TUNE = System::Int8(0x20);
static const System::Int8 SQLITE_TESTCTRL_LAST = System::Int8(0x20);
static const System::Int8 SQLITE_STATUS_MEMORY_USED = System::Int8(0x0);
static const System::Int8 SQLITE_STATUS_PAGECACHE_USED = System::Int8(0x1);
static const System::Int8 SQLITE_STATUS_PAGECACHE_OVERFLOW = System::Int8(0x2);
static const System::Int8 SQLITE_STATUS_SCRATCH_USED = System::Int8(0x3);
static const System::Int8 SQLITE_STATUS_SCRATCH_OVERFLOW = System::Int8(0x4);
static const System::Int8 SQLITE_STATUS_MALLOC_SIZE = System::Int8(0x5);
static const System::Int8 SQLITE_STATUS_PARSER_STACK = System::Int8(0x6);
static const System::Int8 SQLITE_STATUS_PAGECACHE_SIZE = System::Int8(0x7);
static const System::Int8 SQLITE_STATUS_SCRATCH_SIZE = System::Int8(0x8);
static const System::Int8 SQLITE_STATUS_MALLOC_COUNT = System::Int8(0x9);
static const System::Int8 SQLITE_DBSTATUS_LOOKASIDE_USED = System::Int8(0x0);
static const System::Int8 SQLITE_DBSTATUS_CACHE_USED = System::Int8(0x1);
static const System::Int8 SQLITE_DBSTATUS_SCHEMA_USED = System::Int8(0x2);
static const System::Int8 SQLITE_DBSTATUS_STMT_USED = System::Int8(0x3);
static const System::Int8 SQLITE_DBSTATUS_LOOKASIDE_HIT = System::Int8(0x4);
static const System::Int8 SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE = System::Int8(0x5);
static const System::Int8 SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL = System::Int8(0x6);
static const System::Int8 SQLITE_DBSTATUS_CACHE_HIT = System::Int8(0x7);
static const System::Int8 SQLITE_DBSTATUS_CACHE_MISS = System::Int8(0x8);
static const System::Int8 SQLITE_DBSTATUS_CACHE_WRITE = System::Int8(0x9);
static const System::Int8 SQLITE_DBSTATUS_DEFERRED_FKS = System::Int8(0xa);
static const System::Int8 SQLITE_DBSTATUS_CACHE_USED_SHARED = System::Int8(0xb);
static const System::Int8 SQLITE_DBSTATUS_CACHE_SPILL = System::Int8(0xc);
static const System::Int8 SQLITE_DBSTATUS_MAX = System::Int8(0xc);
static const System::Int8 SQLITE_STMTSTATUS_FULLSCAN_STEP = System::Int8(0x1);
static const System::Int8 SQLITE_STMTSTATUS_SORT = System::Int8(0x2);
static const System::Int8 SQLITE_STMTSTATUS_AUTOINDEX = System::Int8(0x3);
static const System::Int8 SQLITE_STMTSTATUS_VM_STEP = System::Int8(0x4);
static const System::Int8 SQLITE_STMTSTATUS_REPREPARE = System::Int8(0x5);
static const System::Int8 SQLITE_STMTSTATUS_RUN = System::Int8(0x6);
static const System::Int8 SQLITE_STMTSTATUS_MEMUSED = System::Int8(0x63);
static const System::Int8 SQLITE_CHECKPOINT_PASSIVE = System::Int8(0x0);
static const System::Int8 SQLITE_CHECKPOINT_FULL = System::Int8(0x1);
static const System::Int8 SQLITE_CHECKPOINT_RESTART = System::Int8(0x2);
static const System::Int8 SQLITE_CHECKPOINT_TRUNCATE = System::Int8(0x3);
static const System::Int8 SQLITE_VTAB_CONSTRAINT_SUPPORT = System::Int8(0x1);
static const System::Int8 SQLITE_VTAB_INNOCUOUS = System::Int8(0x2);
static const System::Int8 SQLITE_VTAB_DIRECTONLY = System::Int8(0x3);
static const System::Int8 SQLITE_ROLLBACK = System::Int8(0x1);
static const System::Int8 SQLITE_FAIL = System::Int8(0x2);
static const System::Int8 SQLITE_REPLACE = System::Int8(0x5);
static const System::Int8 SQLITE_SCANSTAT_NLOOP = System::Int8(0x0);
static const System::Int8 SQLITE_SCANSTAT_NVISIT = System::Int8(0x1);
static const System::Int8 SQLITE_SCANSTAT_EST = System::Int8(0x2);
static const System::Int8 SQLITE_SCANSTAT_NAME = System::Int8(0x3);
static const System::Int8 SQLITE_SCANSTAT_EXPLAIN = System::Int8(0x4);
static const System::Int8 SQLITE_SCANSTAT_SELECTID = System::Int8(0x5);
static const System::Int8 SQLITE_SERIALIZE_NOCOPY = System::Int8(0x1);
static const System::Int8 SQLITE_DESERIALIZE_FREEONCLOSE = System::Int8(0x1);
static const System::Int8 SQLITE_DESERIALIZE_RESIZEABLE = System::Int8(0x2);
static const System::Int8 SQLITE_DESERIALIZE_READONLY = System::Int8(0x4);
static const System::Int8 SQLITEASYNC_HALT _DEPRECATED_ATTRIBUTE0  = System::Int8(0x1);
static const System::Int8 SQLITEASYNC_GET_HALT _DEPRECATED_ATTRIBUTE0  = System::Int8(0x2);
static const System::Int8 SQLITEASYNC_DELAY _DEPRECATED_ATTRIBUTE0  = System::Int8(0x3);
static const System::Int8 SQLITEASYNC_GET_DELAY _DEPRECATED_ATTRIBUTE0  = System::Int8(0x4);
static const System::Int8 SQLITEASYNC_LOCKFILES _DEPRECATED_ATTRIBUTE0  = System::Int8(0x5);
static const System::Int8 SQLITEASYNC_GET_LOCKFILES _DEPRECATED_ATTRIBUTE0  = System::Int8(0x6);
static const System::Int8 SQLITEASYNC_HALT_NEVER _DEPRECATED_ATTRIBUTE0  = System::Int8(0x0);
static const System::Int8 SQLITEASYNC_HALT_NOW _DEPRECATED_ATTRIBUTE0  = System::Int8(0x1);
static const System::Int8 SQLITEASYNC_HALT_IDLE _DEPRECATED_ATTRIBUTE0  = System::Int8(0x2);
static const System::Int8 FTS5_TOKENIZE_QUERY = System::Int8(0x1);
static const System::Int8 FTS5_TOKENIZE_PREFIX = System::Int8(0x2);
static const System::Int8 FTS5_TOKENIZE_DOCUMENT = System::Int8(0x4);
static const System::Int8 FTS5_TOKENIZE_AUX = System::Int8(0x8);
static const System::Int8 FTS5_TOKEN_COLOCATED = System::Int8(0x1);
static const System::Int8 SQLITE_RBU_STATE_OAL = System::Int8(0x1);
static const System::Int8 SQLITE_RBU_STATE_MOVE = System::Int8(0x2);
static const System::Int8 SQLITE_RBU_STATE_CHECKPOINT = System::Int8(0x3);
static const System::Int8 SQLITE_RBU_STATE_DONE = System::Int8(0x4);
static const System::Int8 SQLITE_RBU_STATE_ERROR = System::Int8(0x5);
static const System::Int8 NOT_WITHIN = System::Int8(0x0);
static const System::Int8 PARTLY_WITHIN = System::Int8(0x1);
static const System::Int8 FULLY_WITHIN = System::Int8(0x2);
static const System::Int8 EXPERT_CONFIG_SAMPLE = System::Int8(0x1);
static const System::Int8 EXPERT_REPORT_SQL = System::Int8(0x1);
static const System::Int8 EXPERT_REPORT_INDEXES = System::Int8(0x2);
static const System::Int8 EXPERT_REPORT_PLAN = System::Int8(0x3);
static const System::Int8 EXPERT_REPORT_CANDIDATES = System::Int8(0x4);
static const System::Int8 SQLITE_SESSION_OBJCONFIG_SIZE = System::Int8(0x1);
static const System::Int8 SQLITE_CHANGESETSTART_INVERT = System::Int8(0x2);
static const System::Int8 SQLITE_CHANGESETAPPLY_NOSAVEPOINT = System::Int8(0x1);
static const System::Int8 SQLITE_CHANGESETAPPLY_INVERT = System::Int8(0x2);
static const System::Int8 SQLITE_CHANGESET_DATA = System::Int8(0x1);
static const System::Int8 SQLITE_CHANGESET_NOTFOUND = System::Int8(0x2);
static const System::Int8 SQLITE_CHANGESET_CONFLICT = System::Int8(0x3);
static const System::Int8 SQLITE_CHANGESET_CONSTRAINT = System::Int8(0x4);
static const System::Int8 SQLITE_CHANGESET_FOREIGN_KEY = System::Int8(0x5);
static const System::Int8 SQLITE_CHANGESET_OMIT = System::Int8(0x0);
static const System::Int8 SQLITE_CHANGESET_REPLACE = System::Int8(0x1);
static const System::Int8 SQLITE_CHANGESET_ABORT = System::Int8(0x2);
static const System::Int8 SQLITE_SESSION_CONFIG_STRMSIZE = System::Int8(0x1);
static const System::Int8 CARRAY_INT32 = System::Int8(0x0);
static const System::Int8 CARRAY_INT64 = System::Int8(0x1);
static const System::Int8 CARRAY_DOUBLE = System::Int8(0x2);
static const System::Int8 CARRAY_TEXT = System::Int8(0x3);
static const System::Int8 SQLITE_N_LIMIT = System::Int8(0xc);
#define SQLITE_MASTER_QUOTED L"\"sqlite_master\""
#define SQLITE_TEMP_MASTER_QUOTED L"\"sqlite_temp_master\""
static const System::WideChar WC_REPLACEMENT_CHARACTER = (System::WideChar)(0xfffd);
extern DELPHI_PACKAGE TDIJulianDate __fastcall DateToJulianDate(const System::TDateTime ADate);
extern DELPHI_PACKAGE TDIJulianDate __fastcall DateTimeToJulianDate(const System::TDateTime ADateTime);
extern DELPHI_PACKAGE TDIJulianDate __fastcall FileTimeToJulianDate(const _FILETIME &AFileTime);
extern DELPHI_PACKAGE System::UTF8String __fastcall FloatToSqliteStr _DEPRECATED_ATTRIBUTE0 (const System::Extended AValue, const char ADecimalSeparator = '\x2e', const int APrecision = 0xf);
extern DELPHI_PACKAGE System::UTF8String __fastcall FloatToSqlStr(const System::Extended AValue, const char ADecimalSeparator = '\x2e', int APrecision = 0xf, const int ADecimals = 0x270f);
extern DELPHI_PACKAGE TDIJulianDate __fastcall HmsToJulianDate(const int AHour, const int AMinute, const int ASecond);
extern DELPHI_PACKAGE System::TDateTime __fastcall JulianDateToDate(const TDIJulianDate AJulianDate);
extern DELPHI_PACKAGE System::TDateTime __fastcall JulianDateToDateTime(const TDIJulianDate AJulianDate);
extern DELPHI_PACKAGE _FILETIME __fastcall JulianDateToFileTime(const TDIJulianDate AJulianDate);
extern DELPHI_PACKAGE void __fastcall JulianDateToHms(const TDIJulianDate AJulianDate, /* out */ int &AHour, /* out */ int &AMinute, /* out */ int &ASecond);
extern DELPHI_PACKAGE System::TDateTime __fastcall JulianDateToTime(const TDIJulianDate AJulianDate);
extern DELPHI_PACKAGE void __fastcall JulianDateToYmd(const TDIJulianDate AJulianDate, /* out */ int &AYear, /* out */ int &AMonth, /* out */ int &ADay);
extern DELPHI_PACKAGE System::Extended __fastcall Power10(int Power);
extern DELPHI_PACKAGE System::RawByteString __fastcall QuoteIdent(const System::RawByteString s, const char Quote = '\x22');
extern DELPHI_PACKAGE System::UnicodeString __fastcall QuoteIdent16(const System::UnicodeString s, const char Quote = '\x22');
extern DELPHI_PACKAGE System::RawByteString __fastcall QuotedStr(const System::RawByteString s, const char Quote = '\x22');
extern DELPHI_PACKAGE System::UnicodeString __fastcall QuotedStr16(const System::UnicodeString s, const System::WideChar Quote = (System::WideChar)(0x22));
extern DELPHI_PACKAGE int __fastcall SqlBufToFloat(char * p, int l, /* out */ System::Extended &n, const char DecimalSeparator = '\x2e');
extern DELPHI_PACKAGE int __fastcall SqlStrToFloat(const System::RawByteString s, /* out */ System::Extended &n, const char DecimalSeparator = '\x2e');
extern DELPHI_PACKAGE System::Extended __fastcall SqlBufToFloatDef(const char * p, const int l, const System::Extended Default, const char DecimalSeparator = '\x2e');
extern DELPHI_PACKAGE System::Extended __fastcall SqlStrToFloatDef(const System::RawByteString s, const System::Extended Default, const char DecimalSeparator = '\x2e');
extern DELPHI_PACKAGE int __fastcall SqlBufToFloat16(System::WideChar * p, int l, /* out */ System::Extended &n, const System::WideChar DecimalSeparator = (System::WideChar)(0x2e));
extern DELPHI_PACKAGE int __fastcall SqlStrToFloat16(const System::UnicodeString s, /* out */ System::Extended &n, const System::WideChar DecimalSeparator = (System::WideChar)(0x2e));
extern DELPHI_PACKAGE System::Extended __fastcall SqlBufToFloatDef16(const System::WideChar * p, const int l, const System::Extended Default, const System::WideChar DecimalSeparator = (System::WideChar)(0x2e));
extern DELPHI_PACKAGE System::Extended __fastcall SqlStrToFloatDef16(const System::UnicodeString s, const System::Extended Default, const System::WideChar DecimalSeparator = (System::WideChar)(0x2e));
extern DELPHI_PACKAGE unsigned __fastcall StrLen16(const System::WideChar * Str);
extern DELPHI_PACKAGE TDIJulianDate __fastcall TimeToJulianDate(const System::TDateTime atime);
extern DELPHI_PACKAGE TDIJulianDate __fastcall YmdToJulianDate(int AYear, int AMonth, const int ADay);
extern DELPHI_PACKAGE void __fastcall sqlite3_Destroy_AnsiString(void * p);
extern DELPHI_PACKAGE void __fastcall sqlite3_Destroy_Mem(void * p);
extern DELPHI_PACKAGE void __fastcall sqlite3_Destroy_WideString(void * p);
extern DELPHI_PACKAGE TDISQLite3Affinity __fastcall sqlite3_affinity(const System::RawByteString ADeclaration);
extern DELPHI_PACKAGE TDISQLite3Affinity __fastcall sqlite3_affinity16(const System::UnicodeString ADeclaration);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_params(const sqlite3_stmt_ptr pStmt, const System::TVarRec *Params, const int Params_High);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_str(const sqlite3_stmt_ptr pStmt, const int ParamIdx, System::UTF8String Data);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_str16(const sqlite3_stmt_ptr pStmt, const int ParamIdx, System::UnicodeString Data);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_variant(const sqlite3_stmt_ptr pStmt, const int ParamIdx, const System::Variant &Data);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_VarRec(const sqlite3_stmt_ptr pStmt, const int ParamIdx, const System::TVarRec &Data);
extern DELPHI_PACKAGE System::UTF8String __fastcall sqlite3_database_master(const System::UTF8String DatabaseName = System::UTF8String());
extern DELPHI_PACKAGE System::UnicodeString __fastcall sqlite3_database_master16(const System::UnicodeString DatabaseName = System::UnicodeString());
extern DELPHI_PACKAGE TDISQLite3DatabaseType __fastcall sqlite3_database_type(const System::UTF8String DatabaseName);
extern DELPHI_PACKAGE TDISQLite3DatabaseType __fastcall sqlite3_database_type16(const System::UnicodeString DatabaseName);
extern DELPHI_PACKAGE void __fastcall sqlite3_exec_fast(const sqlite3_ptr DB, const System::UTF8String SQL);
extern DELPHI_PACKAGE void __fastcall sqlite3_exec_fast16(const sqlite3_ptr DB, const System::UnicodeString SQL);
extern DELPHI_PACKAGE bool __fastcall sqlite3_has_data(const sqlite3_ptr DB, const System::UTF8String TableOrViewName);
extern DELPHI_PACKAGE bool __fastcall sqlite3_has_data16(const sqlite3_ptr DB, const System::UnicodeString TableOrViewName);
extern DELPHI_PACKAGE bool __fastcall sqlite3_is_memory_name(const System::UnicodeString DatabaseName);
extern DELPHI_PACKAGE int __fastcall sqlite3_check(const int AErrorCode)/* overload */;
extern DELPHI_PACKAGE int __fastcall sqlite3_check_db _DEPRECATED_ATTRIBUTE0 (const int AErrorCode, const sqlite3_ptr ADB);
extern DELPHI_PACKAGE int __fastcall sqlite3_check(const int AErrorCode, const sqlite3_ptr ADB)/* overload */;
extern DELPHI_PACKAGE int __fastcall sqlite3_check_stmt _DEPRECATED_ATTRIBUTE0 (const int AErrorCode, const sqlite3_stmt_ptr AStmt);
extern DELPHI_PACKAGE int __fastcall sqlite3_check(const int AErrorCode, const sqlite3_stmt_ptr AStmt)/* overload */;
extern DELPHI_PACKAGE void __fastcall sqlite3_raise_exception(const int AErrorCode)/* overload */;
extern DELPHI_PACKAGE void __fastcall sqlite3_raise_exception_db _DEPRECATED_ATTRIBUTE0 (const int AErrorCode, const sqlite3_ptr ADB);
extern DELPHI_PACKAGE void __fastcall sqlite3_raise_exception(const int AErrorCode, const sqlite3_ptr ADB)/* overload */;
extern DELPHI_PACKAGE void __fastcall sqlite3_raise_exception_stmt _DEPRECATED_ATTRIBUTE0 (const int AErrorCode, const sqlite3_stmt_ptr AStmt);
extern DELPHI_PACKAGE void __fastcall sqlite3_raise_exception(const int AErrorCode, const sqlite3_stmt_ptr AStmt)/* overload */;
extern DELPHI_PACKAGE TDISQLite3Encoding __fastcall sqlite3_resolve_encoding(const char * p, const unsigned l);
extern DELPHI_PACKAGE TDISQLite3Encoding __fastcall sqlite3_resolve_encoding16(const System::WideChar * p, const unsigned l);
extern DELPHI_PACKAGE System::UTF8String __fastcall sqlite3_column_str(const sqlite3_stmt_ptr pStmt, const int iCol);
extern DELPHI_PACKAGE System::UnicodeString __fastcall sqlite3_column_str16(const sqlite3_stmt_ptr pStmt, const int iCol);
extern DELPHI_PACKAGE System::UnicodeString __fastcall sqlite3_decode_utf8(const char * p, const NativeInt l)/* overload */;
extern DELPHI_PACKAGE System::UnicodeString __fastcall sqlite3_decode_utf8(const System::UTF8String Value)/* overload */;
extern DELPHI_PACKAGE System::UTF8String __fastcall sqlite3_encode_utf8(const System::WideChar * p, const NativeInt l)/* overload */;
extern DELPHI_PACKAGE System::UTF8String __fastcall sqlite3_encode_utf8(const System::UnicodeString Value)/* overload */;
extern DELPHI_PACKAGE unsigned __fastcall sqlite3_read_utf8(const void * p, const unsigned l, /* out */ unsigned &o);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_str(const sqlite3_context_ptr pCtx, System::UTF8String Data);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_str16(const sqlite3_context_ptr pCtx, System::UnicodeString Data);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_error_str(const sqlite3_context_ptr pCtx, const System::UTF8String Data);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_error_str16(const sqlite3_context_ptr pCtx, const System::UnicodeString Data);
extern DELPHI_PACKAGE System::UTF8String __fastcall sqlite3_value_str(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE System::UnicodeString __fastcall sqlite3_value_str16(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE unsigned __fastcall sqlite3_write_utf8(unsigned c, const void * p);
extern DELPHI_PACKAGE int __fastcall sqlite3Fts2RegisterTokenizer _DEPRECATED_ATTRIBUTE0 (const sqlite3_ptr DB, const System::UTF8String Name, const sqlite3_tokenizer_module_ptr TokenizerModule);
extern DELPHI_PACKAGE int __fastcall sqlite3Fts3RegisterTokenizer(const sqlite3_ptr DB, const System::UTF8String Name, const sqlite3_tokenizer_module_ptr TokenizerModule);
extern DELPHI_PACKAGE fts5_api_ptr __fastcall fts5_api_from_db(const sqlite3_ptr DB);
extern DELPHI_PACKAGE unsigned __fastcall StrLen(const char * s);
extern DELPHI_PACKAGE int __fastcall StrCmp(char * s1, char * s2);
extern DELPHI_PACKAGE int __fastcall sqlite3async_initialize _DEPRECATED_ATTRIBUTE0 (const char * zParent, int isDefault);
extern DELPHI_PACKAGE void __fastcall sqlite3async_shutdown _DEPRECATED_ATTRIBUTE0 ();
extern DELPHI_PACKAGE void __fastcall sqlite3async_run _DEPRECATED_ATTRIBUTE0 ();
extern DELPHI_PACKAGE int __cdecl sqlite3async_control _DEPRECATED_ATTRIBUTE0 (int op);
extern DELPHI_PACKAGE int __fastcall sqlite3DbpageRegister(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3DbstatRegister(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3Fts1Init _DEPRECATED_ATTRIBUTE0 (sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3Fts2Init _DEPRECATED_ATTRIBUTE0 (sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3Fts3Init(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_fts5_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3rbu_step(sqlite3rbu_ptr pRbu);
extern DELPHI_PACKAGE sqlite3rbu_ptr __fastcall sqlite3rbu_open(const char * zTarget, const char * zRbu, const char * zState);
extern DELPHI_PACKAGE sqlite3rbu_ptr __fastcall sqlite3rbu_vacuum(const char * zTarget, const char * zState);
extern DELPHI_PACKAGE sqlite3_ptr __fastcall sqlite3rbu_db(sqlite3rbu_ptr pRbu, int bRbu);
extern DELPHI_PACKAGE int __fastcall sqlite3rbu_close(sqlite3rbu_ptr pRbu, C_char_ptr_ptr pzErrMsg);
extern DELPHI_PACKAGE __int64 __fastcall sqlite3rbu_progress(sqlite3rbu_ptr pRbu);
extern DELPHI_PACKAGE void __fastcall sqlite3rbu_bp_progress(sqlite3rbu_ptr pRbu, C_int_ptr pnOne, C_int_ptr pnTwo);
extern DELPHI_PACKAGE int __fastcall sqlite3rbu_state(sqlite3rbu_ptr pRbu);
extern DELPHI_PACKAGE int __fastcall sqlite3rbu_savestate(sqlite3rbu_ptr pRbu);
extern DELPHI_PACKAGE void __fastcall sqlite3rbu_destroy_vfs(const char * zName);
extern DELPHI_PACKAGE int __fastcall sqlite3rbu_create_vfs(const char * zName, const char * zParent);
extern DELPHI_PACKAGE __int64 __fastcall sqlite3rbu_temp_size_limit(sqlite3rbu_ptr pRbu, __int64 n);
extern DELPHI_PACKAGE __int64 __fastcall sqlite3rbu_temp_size(sqlite3rbu_ptr pRbu);
extern DELPHI_PACKAGE int __fastcall sqlite3RtreeInit(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_rtree_geometry_callback(sqlite3_ptr DB, const char * zGeom, sqlite3_rtree_geometry_xGeom xGeom, char * pContext);
extern DELPHI_PACKAGE int __fastcall sqlite3_rtree_query_callback(sqlite3_ptr DB, const char * zQueryFunc, sqlite3_rtree_query_xQueryFunc xQueryFunc, void * pContext, sqlite3_rtree_query_xDestructor xDestructor);
extern DELPHI_PACKAGE sqlite3expert_ptr __fastcall sqlite3_expert_new(sqlite3_ptr DB, C_char_ptr_ptr pzErr);
extern DELPHI_PACKAGE int __cdecl sqlite3_expert_config(sqlite3expert_ptr p, int op);
extern DELPHI_PACKAGE int __fastcall sqlite3_expert_sql(sqlite3expert_ptr p, const char * zSql, C_char_ptr_ptr pzErr);
extern DELPHI_PACKAGE int __fastcall sqlite3_expert_analyze(sqlite3expert_ptr p, C_char_ptr_ptr pzErr);
extern DELPHI_PACKAGE int __fastcall sqlite3_expert_count(sqlite3expert_ptr p);
extern DELPHI_PACKAGE char * __fastcall sqlite3_expert_report(sqlite3expert_ptr p, int iStmt, int eReport);
extern DELPHI_PACKAGE void __fastcall sqlite3_expert_destroy(sqlite3expert_ptr p);
extern DELPHI_PACKAGE int __fastcall sqlite3session_diff(sqlite3_session_ptr pSession, const char * zFromDb, const char * zTbl, C_char_ptr_ptr pzErrMsg);
extern DELPHI_PACKAGE int __fastcall sqlite3session_create(sqlite3_ptr DB, const char * zDb, sqlite3_session_ptr_ptr ppSession);
extern DELPHI_PACKAGE void __fastcall sqlite3session_delete(sqlite3_session_ptr pSession);
extern DELPHI_PACKAGE void __fastcall sqlite3session_table_filter(sqlite3_session_ptr pSession, sqlite3session_xFilter xFilter, void * pCtx);
extern DELPHI_PACKAGE int __fastcall sqlite3session_attach(sqlite3_session_ptr pSession, const char * zTab);
extern DELPHI_PACKAGE int __fastcall sqlite3session_changeset(sqlite3_session_ptr pSession, C_int_ptr pnChangeset, C_void_ptr_ptr ppChangeset);
extern DELPHI_PACKAGE int __fastcall sqlite3session_changeset_strm(sqlite3_session_ptr pSession, sqlite3session_strm_xOutput xOutput, void * pOut);
extern DELPHI_PACKAGE int __fastcall sqlite3session_patchset_strm(sqlite3_session_ptr pSession, sqlite3session_strm_xOutput xOutput, void * pOut);
extern DELPHI_PACKAGE int __fastcall sqlite3session_patchset(sqlite3_session_ptr pSession, C_int_ptr pnPatchset, C_void_ptr_ptr ppPatchset);
extern DELPHI_PACKAGE int __fastcall sqlite3session_enable(sqlite3_session_ptr pSession, int bEnable);
extern DELPHI_PACKAGE int __fastcall sqlite3session_indirect(sqlite3_session_ptr pSession, int bIndirect);
extern DELPHI_PACKAGE int __fastcall sqlite3session_isempty(sqlite3_session_ptr pSession);
extern DELPHI_PACKAGE int __fastcall sqlite3session_object_config(sqlite3_session_ptr pSession, int op, void * pArg);
extern DELPHI_PACKAGE __int64 __fastcall sqlite3session_changeset_size(sqlite3_session_ptr pSession);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_start(sqlite3_changeset_iter_ptr_ptr ppIter, int nChangeset, void * pChangeset);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_start_v2(sqlite3_changeset_iter_ptr_ptr ppIter, int nChangeset, void * pChangeset, int Flags);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_start_strm(sqlite3_changeset_iter_ptr_ptr ppIter, sqlite3session_strm_xInput xInput, void * pIn);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_start_v2_strm(sqlite3_changeset_iter_ptr_ptr ppIter, sqlite3session_strm_xInput xInput, void * pIn, int Flags);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_next(sqlite3_changeset_iter_ptr pIter);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_op(sqlite3_changeset_iter_ptr pIter, const C_char_ptr_ptr pztag, C_int_ptr pnCol, C_int_ptr pOp, C_int_ptr pbIndirect);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_pk(sqlite3_changeset_iter_ptr pIter, C_unsigned_char_num_array_ptr_ptr pabPk, C_int_ptr pnCol);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_old(sqlite3_changeset_iter_ptr pIter, int iVal, sqlite3_value_ptr_ptr ppValue);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_new(sqlite3_changeset_iter_ptr pIter, int iVal, sqlite3_value_ptr_ptr ppValue);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_conflict(sqlite3_changeset_iter_ptr pIter, int iVal, sqlite3_value_ptr_ptr ppValue);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_fk_conflicts(sqlite3_changeset_iter_ptr pIter, C_int_ptr pnOut);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_finalize(sqlite3_changeset_iter_ptr pIter);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_invert(int nIn, const void * pIn, C_int_ptr pnOut, C_void_ptr_ptr ppOut);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_invert_strm(sqlite3session_strm_xInput xInput, void * pIn, sqlite3session_strm_xOutput xOutput, void * pOut);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_apply_v2(sqlite3_ptr DB, int nChangeset, void * pChangeset, sqlite3session_xFilter xFilter, sqlite3session_xConflict xConflict, void * pCtx, C_void_ptr_ptr ppRebase, C_int_ptr pnRebase, int Flags);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_apply(sqlite3_ptr DB, int nChangeset, void * pChangeset, sqlite3session_xFilter xFilter, sqlite3session_xConflict xConflict, void * pCtx);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_apply_v2_strm(sqlite3_ptr DB, sqlite3session_strm_xInput xInput, void * pIn, sqlite3session_xFilter xFilter, sqlite3session_xConflict xConflict, void * pCtx, C_void_ptr_ptr ppRebase, C_int_ptr pnRebase, int Flags);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_apply_strm(sqlite3_ptr DB, sqlite3session_strm_xInput xInput, void * pIn, sqlite3session_xFilter xFilter, sqlite3session_xConflict xConflict, void * pCtx);
extern DELPHI_PACKAGE int __fastcall sqlite3changegroup_new(sqlite3_changegroup_ptr_ptr ppGrp);
extern DELPHI_PACKAGE int __fastcall sqlite3changegroup_add(sqlite3_changegroup_ptr pGrp, int nData, void * pData);
extern DELPHI_PACKAGE int __fastcall sqlite3changegroup_output(sqlite3_changegroup_ptr pGrp, C_int_ptr pnData, C_void_ptr_ptr ppData);
extern DELPHI_PACKAGE int __fastcall sqlite3changegroup_add_strm(sqlite3_changegroup_ptr pGrp, sqlite3session_strm_xInput xInput, void * pIn);
extern DELPHI_PACKAGE int __fastcall sqlite3changegroup_output_strm(sqlite3_changegroup_ptr pGrp, sqlite3session_strm_xOutput xOutput, void * pOut);
extern DELPHI_PACKAGE void __fastcall sqlite3changegroup_delete(sqlite3_changegroup_ptr pGrp);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_concat(int nA, void * pA, int nB, void * pB, C_int_ptr pnOut, C_void_ptr_ptr ppOut);
extern DELPHI_PACKAGE int __fastcall sqlite3changeset_concat_strm(sqlite3session_strm_xInput xInputA, void * pInA, sqlite3session_strm_xInput xInputB, void * pInB, sqlite3session_strm_xOutput xOutput, void * pOut);
extern DELPHI_PACKAGE int __fastcall sqlite3rebaser_create(sqlite3_rebaser_ptr_ptr ppNew);
extern DELPHI_PACKAGE int __fastcall sqlite3rebaser_configure(sqlite3_rebaser_ptr pRebaser, int nRebase, const void * pRebase);
extern DELPHI_PACKAGE int __fastcall sqlite3rebaser_rebase(sqlite3_rebaser_ptr pRebaser, int nIn, const void * pIn, C_int_ptr pnOut, C_void_ptr_ptr ppOut);
extern DELPHI_PACKAGE int __fastcall sqlite3rebaser_rebase_strm(sqlite3_rebaser_ptr pRebaser, sqlite3session_strm_xInput xInput, void * pIn, sqlite3session_strm_xOutput xOutput, void * pOut);
extern DELPHI_PACKAGE void __fastcall sqlite3rebaser_delete(sqlite3_rebaser_ptr pRebaser);
extern DELPHI_PACKAGE int __fastcall sqlite3session_config(int op, void * pArg);
extern DELPHI_PACKAGE int __fastcall sqlite3_amatch_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_anycollseq_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_appendvfs_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_blobio_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_btreeinfo_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_carray_bind(sqlite3_stmt_ptr pStmt, int i, void * aData, int nData, int mFlags, sqlite3_carray_bind_xDel xDel);
extern DELPHI_PACKAGE int __fastcall sqlite3_carray_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_check_freelist(sqlite3_ptr DB, const char * zDb);
extern DELPHI_PACKAGE int __fastcall sqlite3_checkfreelist_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_checkindex_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_cksumvfs_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_closure_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_completion_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_csv_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_dbdata_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_db_dump(sqlite3_ptr DB, const char * zSchema, const char * zTable, sqlite3_db_dump_callback xCallback, void * pArg);
extern DELPHI_PACKAGE int __fastcall sqlite3_decimal_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_eval_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_explain_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_fossildelta_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_fuzzer_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_ieee_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_json_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_memstat_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_mmap_warm(sqlite3_ptr DB, const char * zDb);
extern DELPHI_PACKAGE int __fastcall sqlite3_nextchar_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE char * __fastcall sqlite3_normalize(const char * zSql);
extern DELPHI_PACKAGE int __fastcall sqlite3_percentile_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_prefixes_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_remember_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_series_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_scrub_backup(const char * zSrcFile, const char * zDestFile, C_char_ptr_ptr pzErrMsg);
extern DELPHI_PACKAGE int __fastcall sqlite3_sha_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_shathree_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_spellfix_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_sqlar_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_stmt_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_totype_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_uint_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_unionvtab_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_urifuncs_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_uuid_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3VdbeBytecodeVtabInit(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_vfsstat_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_wholenumber_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_zipfile_init(sqlite3_ptr DB, C_char_ptr_ptr pzErrMsg, const void * pApi);
extern DELPHI_PACKAGE int __fastcall sqlite3_strglob(const char * zGlob, const char * zStr);
extern DELPHI_PACKAGE int __fastcall sqlite3_strlike(const char * zGlob, const char * zStr, unsigned cEsc);
extern DELPHI_PACKAGE int __fastcall sqlite3_get_table(sqlite3_ptr DB, const char * zSql, Disystemcompat::PPPUtf8CharArray pazResult, System::PInteger pnRow, System::PInteger pnColumn, Disystemcompat::PPUtf8Char pzErrMsg);
extern DELPHI_PACKAGE void __fastcall sqlite3_free_table(Disystemcompat::PPUtf8CharArray resultp);
extern DELPHI_PACKAGE int __fastcall sqlite3_prepare _DEPRECATED_ATTRIBUTE0 (sqlite3_ptr DB, const char * zSql, int nByte, sqlite3_stmt_ptr_ptr ppStmt, const C_char_ptr_ptr pzTail);
extern DELPHI_PACKAGE int __fastcall sqlite3_prepare_v2(sqlite3_ptr DB, const char * zSql, int nByte, sqlite3_stmt_ptr_ptr ppStmt, const C_char_ptr_ptr pzTail);
extern DELPHI_PACKAGE int __fastcall sqlite3_prepare_v3(sqlite3_ptr DB, const char * zSql, int nByte, unsigned prepFlages, sqlite3_stmt_ptr_ptr ppStmt, const C_char_ptr_ptr pzTail);
extern DELPHI_PACKAGE int __fastcall sqlite3_prepare16 _DEPRECATED_ATTRIBUTE0 (sqlite3_ptr DB, const System::WideChar * zSql, int nByte, sqlite3_stmt_ptr_ptr ppStmt, const System::PPWideChar pzTail);
extern DELPHI_PACKAGE int __fastcall sqlite3_prepare16_v2(sqlite3_ptr DB, const System::WideChar * zSql, int nBytes, sqlite3_stmt_ptr_ptr ppStmt, const System::PPWideChar pzTail);
extern DELPHI_PACKAGE int __fastcall sqlite3_prepare16_v3(sqlite3_ptr DB, const System::WideChar * zSql, int nBytes, unsigned prepFlages, sqlite3_stmt_ptr_ptr ppStmt, const System::PPWideChar pzTail);
extern DELPHI_PACKAGE int __fastcall sqlite3_keyword_name(int i, const C_char_ptr_ptr pzName, C_int_ptr pnName);
extern DELPHI_PACKAGE int __fastcall sqlite3_keyword_count();
extern DELPHI_PACKAGE int __fastcall sqlite3_keyword_check(const char * zName, int nName);
extern DELPHI_PACKAGE int __fastcall sqlite3_complete(const char * SQL);
extern DELPHI_PACKAGE int __fastcall sqlite3_complete16(const System::WideChar * SQL);
extern DELPHI_PACKAGE int __fastcall sqlite3_expired _DEPRECATED_ATTRIBUTE0 (sqlite3_ptr pStmt);
extern DELPHI_PACKAGE int __fastcall sqlite3_finalize(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE int __fastcall sqlite3_reset(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE int __fastcall sqlite3_clear_bindings(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE void * __fastcall sqlite3_value_blob(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE int __fastcall sqlite3_value_bytes(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE int __fastcall sqlite3_value_bytes16(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE double __fastcall sqlite3_value_double(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE int __fastcall sqlite3_value_int(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE __int64 __fastcall sqlite3_value_int64(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE unsigned __fastcall sqlite3_value_subtype(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE void * __fastcall sqlite3_value_pointer(sqlite3_value_ptr pValue, const char * zPType);
extern DELPHI_PACKAGE char * __fastcall sqlite3_value_text(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE System::WideChar * __fastcall sqlite3_value_text16(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE System::WideChar * __fastcall sqlite3_value_text16be(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE System::WideChar * __fastcall sqlite3_value_text16le(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE int __fastcall sqlite3_value_type(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE int __fastcall sqlite3_value_nochange(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE int __fastcall sqlite3_value_frombind(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE sqlite3_value_ptr __fastcall sqlite3_value_dup(const sqlite3_value_ptr pOrig);
extern DELPHI_PACKAGE void __fastcall sqlite3_value_free(sqlite3_value_ptr pOld);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_blob(sqlite3_context_ptr pCtx, const void * zData, int nData, TSQLite3_Result_Destructor xDestroy);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_blob64(sqlite3_context_ptr pCtx, const void * zData, unsigned __int64 nData, TSQLite3_Result_Destructor xDestroy);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_double(sqlite3_context_ptr pCtx, const double Data);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_error(sqlite3_context_ptr pCtx, const char * zData, int nData);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_error16(sqlite3_context_ptr pCtx, const System::WideChar * zData, int nData);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_int(sqlite3_context_ptr pCtx, const int Data);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_int64(sqlite3_context_ptr pCtx, const __int64 Data);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_null(sqlite3_context_ptr pCtx);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_pointer(sqlite3_context_ptr pCtx, void * pValue, const char * zPType, sqlite3_result_pointer_destructor xDestructor);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_subtype(sqlite3_context_ptr pCtx, unsigned eSubtype);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_text(sqlite3_context_ptr pCtx, const char * zData, int nData, TSQLite3_Result_Destructor xDestroy);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_text64(sqlite3_context_ptr pCtx, const char * zData, unsigned __int64 nData, TSQLite3_Result_Destructor xDestroy, System::Byte Encoding);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_text16(sqlite3_context_ptr pCtx, const System::WideChar * zData, int nData, TSQLite3_Result_Destructor xDestroy);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_text16be(sqlite3_context_ptr pCtx, const System::WideChar * Data, int nData, TSQLite3_Result_Destructor xDestroy);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_text16le(sqlite3_context_ptr pCtx, const System::WideChar * Data, int nData, TSQLite3_Result_Destructor xDestroy);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_value(sqlite3_context_ptr pCtx, sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_zeroblob(sqlite3_context_ptr pCtx, int n);
extern DELPHI_PACKAGE int __fastcall sqlite3_result_zeroblob64(sqlite3_context_ptr pCtx, unsigned __int64 n);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_error_code(sqlite3_context_ptr pCtx, int ErrCode);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_error_toobig(sqlite3_context_ptr pCtx);
extern DELPHI_PACKAGE void __fastcall sqlite3_result_error_nomem(sqlite3_context_ptr pCtx);
extern DELPHI_PACKAGE int __fastcall sqlite3_step(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE void * __fastcall sqlite3_user_data(sqlite3_context_ptr pCtx);
extern DELPHI_PACKAGE sqlite3_ptr __fastcall sqlite3_context_db_handle(sqlite3_context_ptr pCtx);
extern DELPHI_PACKAGE int __fastcall sqlite3_vtab_nochange(sqlite3_context_ptr pCtx);
extern DELPHI_PACKAGE void * __fastcall sqlite3_aggregate_context(sqlite3_context_ptr pCtx, int nBytes);
extern DELPHI_PACKAGE void * __fastcall sqlite3_get_auxdata(sqlite3_context_ptr pCtx, int nArg);
extern DELPHI_PACKAGE void __fastcall sqlite3_set_auxdata(sqlite3_context_ptr pCtx, int nArg, void * pAux, TSQLite3_AuxData_Destructor xDestroy);
extern DELPHI_PACKAGE int __fastcall sqlite3_aggregate_count _DEPRECATED_ATTRIBUTE0 (sqlite3_context_ptr pCtx);
extern DELPHI_PACKAGE int __fastcall sqlite3_column_count(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE int __fastcall sqlite3_data_count(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE void * __fastcall sqlite3_column_blob(sqlite3_stmt_ptr pStmt, int iCol);
extern DELPHI_PACKAGE int __fastcall sqlite3_column_bytes(sqlite3_stmt_ptr pStmt, int iCol);
extern DELPHI_PACKAGE int __fastcall sqlite3_column_bytes16(sqlite3_stmt_ptr pStmt, int iCol);
extern DELPHI_PACKAGE double __fastcall sqlite3_column_double(sqlite3_stmt_ptr pStmt, int iCol);
extern DELPHI_PACKAGE int __fastcall sqlite3_column_int(sqlite3_stmt_ptr pStmt, int iCol);
extern DELPHI_PACKAGE __int64 __fastcall sqlite3_column_int64(sqlite3_stmt_ptr pStmt, int iCol);
extern DELPHI_PACKAGE char * __fastcall sqlite3_column_text(sqlite3_stmt_ptr pStmt, int iCol);
extern DELPHI_PACKAGE sqlite3_value __fastcall sqlite3_column_value(sqlite3_stmt_ptr pStmt, int iCol);
extern DELPHI_PACKAGE System::WideChar * __fastcall sqlite3_column_text16(sqlite3_stmt_ptr pStmt, int iCol);
extern DELPHI_PACKAGE int __fastcall sqlite3_column_type(sqlite3_stmt_ptr pStmt, int iCol);
extern DELPHI_PACKAGE char * __fastcall sqlite3_column_name(sqlite3_stmt_ptr pStmt, int n);
extern DELPHI_PACKAGE System::WideChar * __fastcall sqlite3_column_name16(sqlite3_stmt_ptr pStmt, int n);
extern DELPHI_PACKAGE char * __fastcall sqlite3_column_decltype(sqlite3_stmt_ptr pStmt, int n);
extern DELPHI_PACKAGE System::WideChar * __fastcall sqlite3_column_decltype16(sqlite3_stmt_ptr pStmt, int n);
extern DELPHI_PACKAGE char * __fastcall sqlite3_column_database_name(sqlite3_stmt_ptr pStmt, int n);
extern DELPHI_PACKAGE System::WideChar * __fastcall sqlite3_column_database_name16(sqlite3_stmt_ptr pStmt, int n);
extern DELPHI_PACKAGE char * __fastcall sqlite3_column_table_name(sqlite3_stmt_ptr pStmt, int n);
extern DELPHI_PACKAGE System::WideChar * __fastcall sqlite3_column_table_name16(sqlite3_stmt_ptr pStmt, int n);
extern DELPHI_PACKAGE char * __fastcall sqlite3_column_origin_name(sqlite3_stmt_ptr pStmt, int n);
extern DELPHI_PACKAGE System::WideChar * __fastcall sqlite3_column_origin_name16(sqlite3_stmt_ptr pStmt, int n);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_blob(sqlite3_stmt_ptr pStmt, int ParamIdx, const void * zData, int nData, TSQLite3_Bind_Destructor xDestroy);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_blob64(sqlite3_stmt_ptr pStmt, int ParamIdx, const void * zData, unsigned __int64 nData, TSQLite3_Bind_Destructor xDestroy);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_double(sqlite3_stmt_ptr pStmt, int i, double Value);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_int(sqlite3_stmt_ptr pStmt, int ParamIdx, int Value);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_int64(sqlite3_stmt_ptr pStmt, int ParamIdx, __int64 Value);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_null(sqlite3_stmt_ptr pStmt, int ParamIdx);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_pointer(sqlite3_stmt_ptr pStmt, int i, void * pPtr, const char * zT, sqlite3_bind_pointer_destructor xDestructor);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_text(sqlite3_stmt_ptr pStmt, int ParamIdx, const char * zData, int nData, TSQLite3_Bind_Destructor xDestroy);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_text64(sqlite3_stmt_ptr pStmt, int ParamIdx, const char * zData, unsigned __int64 nData, TSQLite3_Bind_Destructor xDestroy, System::Byte Encoding);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_text16(sqlite3_stmt_ptr pStmt, int ParamIdx, const System::WideChar * zData, int nData, TSQLite3_Bind_Destructor xDestroy);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_value(sqlite3_stmt_ptr pStmt, int ParamIdx, const sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_zeroblob(sqlite3_stmt_ptr pStmt, int ParamIdx, int n);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_zeroblob64(sqlite3_stmt_ptr pStmt, int ParamIdx, unsigned __int64 n);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_parameter_count(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE char * __fastcall sqlite3_bind_parameter_name(sqlite3_stmt_ptr pStmt, int n);
extern DELPHI_PACKAGE int __fastcall sqlite3_bind_parameter_index(sqlite3_stmt_ptr pStmt, const char * zName);
extern DELPHI_PACKAGE int __fastcall sqlite3_transfer_bindings _DEPRECATED_ATTRIBUTE0 (sqlite3_stmt_ptr pFromStmt, sqlite3_stmt_ptr pToStmt);
extern DELPHI_PACKAGE sqlite3_ptr __fastcall sqlite3_db_handle(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE int __fastcall sqlite3_stmt_readonly(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE int __fastcall sqlite3_stmt_isexplain(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE int __fastcall sqlite3_stmt_busy(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE sqlite3_stmt_ptr __fastcall sqlite3_next_stmt(sqlite3_ptr pDb, sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE int __fastcall sqlite3_stmt_status(sqlite3_stmt_ptr Stmt, int op, int resetFlg);
extern DELPHI_PACKAGE char * __fastcall sqlite3_sql(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE char * __fastcall sqlite3_expanded_sql(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE char * __fastcall sqlite3_normalized_sql(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE int __fastcall sqlite3_preupdate_old(sqlite3_ptr DB, int iIdx, sqlite3_value_ptr_ptr ppValue);
extern DELPHI_PACKAGE int __fastcall sqlite3_preupdate_count(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_preupdate_depth(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_preupdate_blobwrite(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_preupdate_new(sqlite3_ptr DB, int iIdx, sqlite3_value_ptr_ptr ppValue);
extern DELPHI_PACKAGE int __fastcall sqlite3_stmt_scanstatus(sqlite3_stmt_ptr pStmt, int Idx, int iScanStatusOp, void * pOut);
extern DELPHI_PACKAGE void __fastcall sqlite3_stmt_scanstatus_reset(sqlite3_stmt_ptr pStmt);
extern DELPHI_PACKAGE int __fastcall sqlite3_value_numeric_type(sqlite3_value_ptr pValue);
extern DELPHI_PACKAGE char * __fastcall sqlite3_libversion();
extern DELPHI_PACKAGE char * __fastcall sqlite3_sourceid();
extern DELPHI_PACKAGE int __fastcall sqlite3_libversion_number();
extern DELPHI_PACKAGE int __fastcall sqlite3_threadsafe();
extern DELPHI_PACKAGE int __fastcall sqlite3_initialize();
extern DELPHI_PACKAGE int __fastcall sqlite3_shutdown();
extern DELPHI_PACKAGE int __cdecl sqlite3_config(int op);
extern DELPHI_PACKAGE sqlite3_mutex_ptr __fastcall sqlite3_db_mutex(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_db_release_memory(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_db_cacheflush(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __cdecl sqlite3_db_config(sqlite3_ptr DB, int op);
extern DELPHI_PACKAGE __int64 __fastcall sqlite3_last_insert_rowid(sqlite3_ptr DB);
extern DELPHI_PACKAGE void __fastcall sqlite3_set_last_insert_rowid(sqlite3_ptr DB, __int64 iRowId);
extern DELPHI_PACKAGE int __fastcall sqlite3_changes(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_total_changes(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_txn_state(sqlite3_ptr DB, const char * zSchema);
extern DELPHI_PACKAGE int __fastcall sqlite3_close(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_close_v2(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_busy_handler(sqlite3_ptr DB, TSQLite3_Busy_Callback Callback, void * UserData);
extern DELPHI_PACKAGE void __fastcall sqlite3_progress_handler(sqlite3_ptr DB, int n, TSQLite3_Progress_Callback Callback, void * UserData);
extern DELPHI_PACKAGE int __fastcall sqlite3_busy_timeout(sqlite3_ptr DB, int ms);
extern DELPHI_PACKAGE void __fastcall sqlite3_interrupt(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_create_function(sqlite3_ptr DB, const char * zFunctionName, int nArg, int eTextRep, void * pApp, TSQLite3_Func_Callback xFunc, TSQLite3_Step_Callback xStep, TSQLite3_Final_Callback xFinal);
extern DELPHI_PACKAGE int __fastcall sqlite3_create_function_v2(sqlite3_ptr DB, const char * zFunctionName, int nArg, int eTextRep, void * pApp, TSQLite3_Func_Callback xFunc, TSQLite3_Step_Callback xStep, TSQLite3_Final_Callback xFinal, TSQLite3_Destroy_Callback xDestroy);
extern DELPHI_PACKAGE int __fastcall sqlite3_create_window_function(sqlite3_ptr DB, const char * zFunctionName, int nArg, int eTextRep, void * pApp, TSQLite3_Step_Callback xStep, TSQLite3_Final_Callback xFinal, TSQLite3_Value_Callback xValue, TSQLite3_Inverse_Callback xInverse, TSQLite3_Destroy_Callback xDestroy);
extern DELPHI_PACKAGE int __fastcall sqlite3_create_function16(sqlite3_ptr DB, const System::WideChar * zFunctionName, int nArg, int eTextRep, void * pApp, TSQLite3_Func_Callback xFunc, TSQLite3_Step_Callback xStep, TSQLite3_Final_Callback xFinal);
extern DELPHI_PACKAGE int __fastcall sqlite3_overload_function(sqlite3_ptr DB, const char * zFuncName, int nArg);
extern DELPHI_PACKAGE void * __fastcall sqlite3_trace _DEPRECATED_ATTRIBUTE1("Use sqlite3_trace_v2() instead") (sqlite3_ptr DB, TSQLite3_Trace_Callback xTrace, void * pArg);
extern DELPHI_PACKAGE int __fastcall sqlite3_trace_v2(sqlite3_ptr DB, unsigned uMask, sqlite3_trace_v2_callback xCallback, void * pCtx);
extern DELPHI_PACKAGE void * __fastcall sqlite3_profile _DEPRECATED_ATTRIBUTE1("Use sqlite3_trace_v2() instead") (sqlite3_ptr DB, TSQLite3_Profile_Callback Callback, void * UserData);
extern DELPHI_PACKAGE void * __fastcall sqlite3_commit_hook(sqlite3_ptr DB, TSQLite3_Commit_Callback Callback, void * pArg);
extern DELPHI_PACKAGE void * __fastcall sqlite3_update_hook(sqlite3_ptr DB, sqlite3_update_hook_callback xCallback, void * Part);
extern DELPHI_PACKAGE void * __fastcall sqlite3_rollback_hook(sqlite3_ptr DB, TSQLite3_Rollback_Callback Callback, void * pArg);
extern DELPHI_PACKAGE void * __fastcall sqlite3_preupdate_hook(sqlite3_ptr DB, sqlite3_preupdate_hook_callback xPreUpdate, void * pArg);
extern DELPHI_PACKAGE int __fastcall sqlite3_wal_autocheckpoint(sqlite3_ptr DB, int nFrame);
extern DELPHI_PACKAGE void * __fastcall sqlite3_wal_hook(sqlite3_ptr DB, sqlite3_wal_hook_callback xCallback, void * pArg);
extern DELPHI_PACKAGE int __fastcall sqlite3_wal_checkpoint_v2(sqlite3_ptr DB, const char * zDb, int eMode, C_int_ptr pnLog, C_int_ptr pnCkpt);
extern DELPHI_PACKAGE int __fastcall sqlite3_wal_checkpoint(sqlite3_ptr DB, const char * zDb);
extern DELPHI_PACKAGE char * __fastcall sqlite3_errmsg(sqlite3_ptr DB);
extern DELPHI_PACKAGE System::WideChar * __fastcall sqlite3_errmsg16(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_errcode(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_extended_errcode(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __fastcall sqlite3_system_errno(sqlite3_ptr DB);
extern DELPHI_PACKAGE char * __fastcall sqlite3_errstr(int RC);
extern DELPHI_PACKAGE int __fastcall sqlite3_limit(sqlite3_ptr DB, int ID, int newVal);
extern DELPHI_PACKAGE int __fastcall sqlite3_open(char * FileName, sqlite3_ptr_ptr ppDB);
extern DELPHI_PACKAGE int __fastcall sqlite3_open_v2(const char * FileName, sqlite3_ptr_ptr ppDB, int Flags, const char * zVfs);
extern DELPHI_PACKAGE int __fastcall sqlite3_open16(System::WideChar * FileName, sqlite3_ptr_ptr ppDB);
extern DELPHI_PACKAGE int __fastcall sqlite3_create_collation(sqlite3_ptr DB, const char * zName, int eTextRep, void * pApp, TSQLite3_Collation_Callback xCompare);
extern DELPHI_PACKAGE int __fastcall sqlite3_create_collation_v2(sqlite3_ptr DB, const char * zName, int eTextRep, void * pApp, TSQLite3_Collation_Callback xCompare, TSQLite3_Collation_Destructor xDestroy);
extern DELPHI_PACKAGE int __fastcall sqlite3_create_collation16(sqlite3_ptr DB, const System::WideChar * zName, int eTextRep, void * pApp, TSQLite3_Collation_Callback xCompare);
extern DELPHI_PACKAGE int __fastcall sqlite3_collation_needed(sqlite3_ptr DB, void * UserData, TSQLite3_Collation_Needed_Callback Callback);
extern DELPHI_PACKAGE int __fastcall sqlite3_collation_needed16(sqlite3_ptr DB, void * UserData, TSQLite3_Collation_Needed16_Callback Callback);
extern DELPHI_PACKAGE int __fastcall sqlite3_global_recover _DEPRECATED_ATTRIBUTE0 ();
extern DELPHI_PACKAGE int __fastcall sqlite3_get_autocommit(sqlite3_ptr DB);
extern DELPHI_PACKAGE void __fastcall sqlite3_thread_cleanup _DEPRECATED_ATTRIBUTE0 ();
extern DELPHI_PACKAGE int __fastcall sqlite3_table_column_metadata(sqlite3_ptr DB, const char * zDbName, const char * zTableName, const char * zColumnName, const Disystemcompat::PPUtf8Char pzDataType, const Disystemcompat::PPUtf8Char pzCollSeq, System::PInteger pNotNull, System::PInteger pPrimaryKey, System::PInteger pAutoInc);
extern DELPHI_PACKAGE int __fastcall sqlite3_sleep(int ms);
extern DELPHI_PACKAGE int __fastcall sqlite3_extended_result_codes(sqlite3_ptr DB, int onoff);
extern DELPHI_PACKAGE int __fastcall sqlite3_file_control(sqlite3_ptr DB, const char * zDbName, int op, void * pArg);
extern DELPHI_PACKAGE int __cdecl sqlite3_test_control(int op);
extern DELPHI_PACKAGE char * __fastcall sqlite3_create_filename(const char * zDatabase, const char * zJournal, const char * zWal, int nParam, const C_char_ptr_array_ptr azParam);
extern DELPHI_PACKAGE void __fastcall sqlite3_free_filename(char * p);
extern DELPHI_PACKAGE char * __fastcall sqlite3_uri_parameter(const char * zFileName, const char * zParam);
extern DELPHI_PACKAGE char * __fastcall sqlite3_uri_key(const char * zFileName, int n);
extern DELPHI_PACKAGE int __fastcall sqlite3_uri_boolean(const char * zFile, const char * zParam, int bDefault);
extern DELPHI_PACKAGE __int64 __fastcall sqlite3_uri_int64(const char * zFile, const char * zParam, __int64 iDefault);
extern DELPHI_PACKAGE char * __fastcall sqlite3_filename_database(const char * zFileName);
extern DELPHI_PACKAGE char * __fastcall sqlite3_filename_journal(const char * zFileName);
extern DELPHI_PACKAGE char * __fastcall sqlite3_filename_wal(const char * zFileName);
extern DELPHI_PACKAGE char * __fastcall sqlite3_db_filename(sqlite3_ptr DB, const char * zDbName);
extern DELPHI_PACKAGE int __fastcall sqlite3_db_readonly(sqlite3_ptr DB, const char * zDbName);
extern DELPHI_PACKAGE int __fastcall sqlite3_snapshot_get(sqlite3_ptr sqlite3, const char * zSchema, sqlite3_snapshot_ptr_ptr ppSnapshot);
extern DELPHI_PACKAGE int __fastcall sqlite3_snapshot_open(sqlite3_ptr sqlite3, const char * zSchema, sqlite3_snapshot_ptr pSnapshot);
extern DELPHI_PACKAGE int __fastcall sqlite3_snapshot_recover(sqlite3_ptr sqlite3, const char * zDb);
extern DELPHI_PACKAGE void __fastcall sqlite3_snapshot_free(sqlite3_snapshot_ptr pSnapshot);
extern DELPHI_PACKAGE int __fastcall sqlite3_compileoption_used(char * zOptName);
extern DELPHI_PACKAGE char * __fastcall sqlite3_compileoption_get(int n);
extern DELPHI_PACKAGE int __fastcall sqlite3_load_extension(sqlite3_ptr DB, const char * zFile, const char * zProc, C_char_ptr_ptr pzErrMsg);
extern DELPHI_PACKAGE int __fastcall sqlite3_enable_load_extension(sqlite3_ptr DB, int onoff);
extern DELPHI_PACKAGE int __fastcall sqlite3_auto_extension(xEntryPoint xInit);
extern DELPHI_PACKAGE int __fastcall sqlite3_cancel_auto_extension(xEntryPoint xInit);
extern DELPHI_PACKAGE void __fastcall sqlite3_reset_auto_extension();
extern DELPHI_PACKAGE int __fastcall sqlite3_create_module(sqlite3_ptr DB, const char * zName, const sqlite3_module_ptr Module, void * pClientData);
extern DELPHI_PACKAGE int __fastcall sqlite3_create_module_v2(sqlite3_ptr DB, const char * zName, const sqlite3_module_ptr Module, void * pClientData, TSQLite3_Module_Destructor xDestroy);
extern DELPHI_PACKAGE int __fastcall sqlite3_drop_modules(sqlite3_ptr DB, const C_char_ptr_array_ptr azKeep);
extern DELPHI_PACKAGE int __fastcall sqlite3_declare_vtab(sqlite3_ptr DB, const char * zCreateTable);
extern DELPHI_PACKAGE int __fastcall sqlite3_vtab_on_conflict(sqlite3_ptr DB);
extern DELPHI_PACKAGE int __cdecl sqlite3_vtab_config(sqlite3_ptr DB, int op);
extern DELPHI_PACKAGE int __fastcall sqlite3_key(sqlite3_ptr DB, const char * pKey, int nKey);
extern DELPHI_PACKAGE int __fastcall sqlite3_key_v2(sqlite3_ptr DB, const char * zDbName, const char * pKey, int nKey);
extern DELPHI_PACKAGE int __fastcall sqlite3_rekey(sqlite3_ptr DB, const char * pKey, int nKey);
extern DELPHI_PACKAGE int __fastcall sqlite3_rekey_v2(sqlite3_ptr DB, const char * zDbName, const char * pKey, int nKey);
extern DELPHI_PACKAGE int __fastcall sqlite3_exec(sqlite3_ptr DB, const char * SQL, TSQLite3_Callback Callback, void * UserData, Disystemcompat::PPUtf8Char ErrMsg);
extern DELPHI_PACKAGE char * __fastcall sqlite3_vtab_collation(sqlite3_index_info_ptr pIdxInfo, int iCons);
extern DELPHI_PACKAGE int __fastcall sqlite3_set_authorizer(sqlite3_ptr DB, TSQLite3_Authorizer_Callback Callback, void * UserData);
extern DELPHI_PACKAGE int __fastcall sqlite3_blob_open(sqlite3_ptr DB, const char * zDb, const char * zTable, const char * zColumn, __int64 iRow, int Flags, sqlite3_blob_ptr_ptr ppBlob);
extern DELPHI_PACKAGE int __fastcall sqlite3_blob_close(sqlite3_blob_ptr pBlob);
extern DELPHI_PACKAGE int __fastcall sqlite3_blob_read(sqlite3_blob_ptr pBlob, void * z, int n, int iOffset);
extern DELPHI_PACKAGE int __fastcall sqlite3_blob_write(sqlite3_blob_ptr pBlob, const void * z, int n, int iOffset);
extern DELPHI_PACKAGE int __fastcall sqlite3_blob_bytes(sqlite3_blob_ptr pBlob);
extern DELPHI_PACKAGE int __fastcall sqlite3_blob_reopen(sqlite3_blob_ptr pBlob, __int64 iRow);
extern DELPHI_PACKAGE int __fastcall sqlite3_enable_shared_cache(int Value);
extern DELPHI_PACKAGE sqlite3_mutex_ptr __fastcall sqlite3_mutex_alloc(int iType);
extern DELPHI_PACKAGE void __fastcall sqlite3_mutex_free(sqlite3_mutex_ptr p);
extern DELPHI_PACKAGE void __fastcall sqlite3_mutex_enter(sqlite3_mutex_ptr p);
extern DELPHI_PACKAGE int __fastcall sqlite3_mutex_try(sqlite3_mutex_ptr p);
extern DELPHI_PACKAGE void __fastcall sqlite3_mutex_leave(sqlite3_mutex_ptr p);
extern DELPHI_PACKAGE int __fastcall sqlite3_unlock_notify(sqlite3_ptr pBlocked, TSQLite3_unlock_notify_callback xNotify, void * pNotifyArg);
extern DELPHI_PACKAGE sqlite3_backup_ptr __fastcall sqlite3_backup_init(sqlite3_ptr pDest, const char * zDestName, sqlite3_ptr pSource, const char * zSourceName);
extern DELPHI_PACKAGE int __fastcall sqlite3_backup_step(sqlite3_backup_ptr p, int nPage);
extern DELPHI_PACKAGE int __fastcall sqlite3_backup_finish(sqlite3_backup_ptr p);
extern DELPHI_PACKAGE int __fastcall sqlite3_backup_remaining(sqlite3_backup_ptr p);
extern DELPHI_PACKAGE int __fastcall sqlite3_backup_pagecount(sqlite3_backup_ptr p);
extern DELPHI_PACKAGE int __fastcall sqlite3_snapshot_cmp(sqlite3_snapshot_ptr p1, sqlite3_snapshot_ptr p2);
extern DELPHI_PACKAGE sqlite3_file_ptr __fastcall sqlite3_database_file_object(const char * zName);
extern DELPHI_PACKAGE int __fastcall sqlite3_stricmp(const char * zLeft, const char * zRight);
extern DELPHI_PACKAGE int __fastcall sqlite3_strnicmp(const char * zLeft, const char * zRight, int n);
extern DELPHI_PACKAGE void __fastcall sqlite3_randomness(int n, void * p);
extern DELPHI_PACKAGE void __cdecl sqlite3_str_vappendf(sqlite3_str_ptr p, const char * zFormat, void * ap);
extern DELPHI_PACKAGE void __fastcall sqlite3_str_appendchar(sqlite3_str_ptr p, int n, char c);
extern DELPHI_PACKAGE void __fastcall sqlite3_str_append(sqlite3_str_ptr p, const char * zIn, int n);
extern DELPHI_PACKAGE void __fastcall sqlite3_str_appendall(sqlite3_str_ptr p, const char * zIn);
extern DELPHI_PACKAGE char * __fastcall sqlite3_str_finish(sqlite3_str_ptr p);
extern DELPHI_PACKAGE int __fastcall sqlite3_str_errcode(sqlite3_str_ptr p);
extern DELPHI_PACKAGE int __fastcall sqlite3_str_length(sqlite3_str_ptr p);
extern DELPHI_PACKAGE char * __fastcall sqlite3_str_value(sqlite3_str_ptr p);
extern DELPHI_PACKAGE void __fastcall sqlite3_str_reset(sqlite3_str_ptr p);
extern DELPHI_PACKAGE sqlite3_str_ptr __fastcall sqlite3_str_new(sqlite3_ptr DB);
extern DELPHI_PACKAGE char * __cdecl sqlite3_mprintf(char * zFormat);
extern DELPHI_PACKAGE char * __cdecl sqlite3_snprintf(int BufSize, char * zBuf, char * zFormat);
extern DELPHI_PACKAGE void __cdecl sqlite3_log(int iErrCode, const char * zFormat);
extern DELPHI_PACKAGE void __cdecl sqlite3_str_appendf(sqlite3_str_ptr p, const char * zFormat);
extern DELPHI_PACKAGE int __fastcall sqlite3_release_memory(int n);
extern DELPHI_PACKAGE int __fastcall sqlite3_memory_alarm _DEPRECATED_ATTRIBUTE0 (TSQLite3_Memory_Alarm_Callback xCallback, void * pArg, __int64 iThreshold);
extern DELPHI_PACKAGE __int64 __fastcall sqlite3_soft_heap_limit64(__int64 n);
extern DELPHI_PACKAGE void __fastcall sqlite3_soft_heap_limit _DEPRECATED_ATTRIBUTE0 (int n);
extern DELPHI_PACKAGE __int64 __fastcall sqlite3_hard_heap_limit64(__int64 n);
extern DELPHI_PACKAGE __int64 __fastcall sqlite3_memory_used _DEPRECATED_ATTRIBUTE0 ();
extern DELPHI_PACKAGE __int64 __fastcall sqlite3_memory_highwater _DEPRECATED_ATTRIBUTE0 (int resetFlag);
extern DELPHI_PACKAGE void * __fastcall sqlite3_malloc(int n);
extern DELPHI_PACKAGE void * __fastcall sqlite3_malloc64(unsigned __int64 n);
extern DELPHI_PACKAGE unsigned __int64 __fastcall sqlite3_msize(void * p);
extern DELPHI_PACKAGE void __fastcall sqlite3_free(void * p);
extern DELPHI_PACKAGE void * __fastcall sqlite3_realloc(void * pOld, int n);
extern DELPHI_PACKAGE void * __fastcall sqlite3_realloc64(void * pOld, unsigned __int64 n);
extern DELPHI_PACKAGE int __fastcall sqlite3_status64(int op, sqlite3_int64_ptr pCurrent, sqlite3_int64_ptr pHighwater, int resetFlag);
extern DELPHI_PACKAGE int __fastcall sqlite3_status(int op, System::PInteger pCurrent, System::PInteger pHighwater, int resetFlag);
extern DELPHI_PACKAGE int __fastcall sqlite3_db_status(sqlite3_ptr DB, int op, C_int_ptr pCurrent, C_int_ptr pHighwater, int resetFlag);
extern DELPHI_PACKAGE void * __fastcall sqlite3_serialize(sqlite3_ptr DB, const char * zSchema, sqlite3_int64_ptr piSize, unsigned mFlags);
extern DELPHI_PACKAGE int __fastcall sqlite3_deserialize(sqlite3_ptr DB, const char * zSchema, void * pData, __int64 szDb, __int64 szBuf, unsigned mFlags);
extern DELPHI_PACKAGE sqlite3_vfs_ptr __fastcall sqlite3_vfs_find(const char * zVfsName);
extern DELPHI_PACKAGE int __fastcall sqlite3_vfs_register(sqlite3_vfs_ptr pVfs, int makeDflt);
extern DELPHI_PACKAGE int __fastcall sqlite3_vfs_unregister(sqlite3_vfs_ptr pVfs);
extern DELPHI_PACKAGE int __fastcall sqlite3_os_init();
extern DELPHI_PACKAGE int __fastcall sqlite3_os_end();
}	/* namespace Disqlite3api */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_DISQLITE3API)
using namespace Disqlite3api;
#endif
#pragma pack(pop)
#pragma option pop

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// Disqlite3apiHPP
