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

// (DO NOT EDIT: machine generated header) 'ABSMain.pas' rev: 35.00 (Windows)

#ifndef AbsmainHPP
#define AbsmainHPP

#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 <System.SysUtils.hpp>
#include <System.Math.hpp>
#include <System.Classes.hpp>
#include <Data.DB.hpp>
#include <Winapi.Windows.hpp>
#include <Vcl.Dialogs.hpp>
#include <Vcl.Forms.hpp>
#include <Vcl.Controls.hpp>
#include <System.Generics.Collections.hpp>
#include <Data.DBCommon.hpp>
#include <System.Variants.hpp>
#include <Data.SqlTimSt.hpp>
#include <System.Win.Registry.hpp>
#include <ABSLocalEngine.hpp>
#include <ABSBase.hpp>
#include <ABSDlgWait.hpp>
#include <ABSCompression.hpp>
#include <ABSSecurity.hpp>
#include <ABSVariant.hpp>
#include <ABSConverts.hpp>
#include <ABSExcept.hpp>
#include <ABSSQLProcessor.hpp>
#include <ABSLexer.hpp>
#include <ABSTypes.hpp>
#include <ABSConst.hpp>
#include <ABSMemory.hpp>
#include <System.Generics.Defaults.hpp>
#include <System.Types.hpp>

//-- user supplied -----------------------------------------------------------

namespace Absmain
{
//-- forward type declarations -----------------------------------------------
class DELPHICLASS EABSEngineError;
class DELPHICLASS TABSBLOBStream;
class DELPHICLASS TABSSessionList;
class DELPHICLASS TABSSession;
class DELPHICLASS TABSDataSet;
class DELPHICLASS TABSExportToSqlOptions;
class DELPHICLASS TABSTable;
class DELPHICLASS TABSQuery;
class DELPHICLASS TABSDatabase;
class DELPHICLASS TABSAdvFieldDef;
class DELPHICLASS TABSAdvFieldDefs;
class DELPHICLASS TABSAdvIndexDef;
class DELPHICLASS TABSAdvIndexDefs;
//-- type declarations -------------------------------------------------------
enum DECLSPEC_DENUM TABSEngineType : unsigned char { etLocal, etClient, etServer };

enum DECLSPEC_DENUM TCompressionAlgorithm : unsigned char { caNone, caZLIB, caBZIP, caPPM };

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

#pragma pack(pop)

class PASCALIMPLEMENTATION TABSBLOBStream : public Abscompression::TABSStream
{
	typedef Abscompression::TABSStream inherited;
	
private:
	Data::Db::TBlobField* FField;
	TABSDataSet* FDataSet;
	Abscompression::TABSStream* FBLOBStream;
	
protected:
	void __fastcall InternalSetSize(const __int64 NewSize);
	virtual void __fastcall SetSize(int NewSize)/* overload */;
	virtual void __fastcall SetSize(const __int64 NewSize)/* overload */;
	__int64 __fastcall GetCompressedSize();
	
public:
	virtual int __fastcall Read(void *Buffer, int Count)/* overload */;
	virtual int __fastcall Write(const void *Buffer, int Count)/* overload */;
	virtual int __fastcall Seek(int Offset, System::Word Origin)/* overload */;
	virtual __int64 __fastcall Seek(const __int64 Offset, System::Classes::TSeekOrigin Origin)/* overload */;
	__fastcall TABSBLOBStream(Data::Db::TBlobField* Field, Data::Db::TBlobStreamMode Mode);
	__fastcall virtual ~TABSBLOBStream();
	void __fastcall Truncate();
	__property Abscompression::TABSStream* BLOBStream = {read=FBLOBStream};
	__property __int64 CompressedSize = {read=GetCompressedSize};
	/* Hoisted overloads: */
	
public:
	inline int __fastcall  Read(System::DynamicArray<System::Byte> Buffer, int Offset, int Count){ return System::Classes::TStream::Read(Buffer, Offset, Count); }
	inline int __fastcall  Read(System::DynamicArray<System::Byte> &Buffer, int Count){ return System::Classes::TStream::Read(Buffer, Count); }
	inline int __fastcall  Write(const System::DynamicArray<System::Byte> Buffer, int Offset, int Count){ return System::Classes::TStream::Write(Buffer, Offset, Count); }
	inline int __fastcall  Write(const System::DynamicArray<System::Byte> Buffer, int Count){ return System::Classes::TStream::Write(Buffer, Count); }
	inline __int64 __fastcall  Seek(const __int64 Offset, System::Word Origin){ return System::Classes::TStream::Seek(Offset, Origin); }
	
};


#pragma pack(push,4)
class PASCALIMPLEMENTATION TABSSessionList : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	TABSSession* operator[](int Index) { return this->Sessions[Index]; }
	
private:
	System::Classes::TThreadList* FSessions;
	System::Classes::TBits* FSessionNumbers;
	void __fastcall AddSession(TABSSession* ASession);
	void __fastcall CloseAll();
	int __fastcall GetCount();
	TABSSession* __fastcall GetSession(int Index);
	TABSSession* __fastcall GetCurrentSession();
	TABSSession* __fastcall GetSessionByName(const System::UnicodeString SessionName);
	void __fastcall SetCurrentSession(TABSSession* Value);
	
public:
	__fastcall TABSSessionList();
	__fastcall virtual ~TABSSessionList();
	TABSSession* __fastcall FindSession(const System::UnicodeString SessionName);
	void __fastcall GetSessionNames(System::Classes::TStrings* List);
	TABSSession* __fastcall OpenSession(const System::UnicodeString SessionName);
	__property int Count = {read=GetCount, nodefault};
	__property TABSSession* CurrentSession = {read=GetCurrentSession, write=SetCurrentSession};
	__property TABSSession* Sessions[int Index] = {read=GetSession/*, default*/};
	__property TABSSession* List[const System::UnicodeString SessionName] = {read=GetSessionByName};
};

#pragma pack(pop)

enum DECLSPEC_DENUM TABSDatabaseEvent : unsigned char { dbOpen, dbClose, dbAdd, dbRemove };

typedef void __fastcall (__closure *TABSDatabaseNotifyEvent)(TABSDatabaseEvent DBEvent, const void *Param);

typedef void __fastcall (__closure *TABSPasswordEvent)(System::TObject* Sender, bool &Continue);

typedef void __fastcall (__closure *TABSProgressEvent)(System::TObject* Sender, int PercentDone, bool &Continue);

typedef void __fastcall (__closure *TABSDataSetNotifyEvent)(System::TObject* DataSet);

class PASCALIMPLEMENTATION TABSSession : public System::Classes::TComponent
{
	typedef System::Classes::TComponent inherited;
	
private:
	Absbase::TABSSessionComponentManager* FHandle;
	System::Classes::TList* FDatabases;
	bool FStreamedActive;
	bool FKeepConnections;
	bool FDefault;
	bool FAutoSessionName;
	bool FUpdatingAutoSessionName;
	System::UnicodeString FSessionName;
	int FSessionNumber;
	TABSDatabaseNotifyEvent FOnDBNotify;
	System::Classes::TNotifyEvent FOnStartup;
	void __fastcall AddDatabase(TABSDatabase* Value);
	void __fastcall CheckInactive();
	void __fastcall DBNotification(TABSDatabaseEvent DBEvent, const void *Param);
	TABSDatabase* __fastcall DoFindDatabase(const System::UnicodeString DatabaseName, System::Classes::TComponent* AOwner);
	TABSDatabase* __fastcall DoOpenDatabase(const System::UnicodeString DatabaseName, System::Classes::TComponent* AOwner);
	Absbase::TABSBaseSession* __fastcall FindDatabaseHandle(const System::UnicodeString DatabaseName);
	bool __fastcall GetActive();
	TABSDatabase* __fastcall GetDatabase(int Index);
	int __fastcall GetDatabaseCount();
	Absbase::TABSSessionComponentManager* __fastcall GetHandle();
	bool __fastcall SessionNameStored();
	void __fastcall MakeCurrent();
	void __fastcall RemoveDatabase(TABSDatabase* Value);
	void __fastcall SetActive(bool Value);
	void __fastcall SetAutoSessionName(bool Value);
	void __fastcall SetSessionName(const System::UnicodeString Value);
	void __fastcall SetSessionNames();
	void __fastcall StartSession(bool Value);
	void __fastcall UpdateAutoSessionName();
	void __fastcall ValidateAutoSession(System::Classes::TComponent* AOwner, bool AllSessions);
	
protected:
	virtual void __fastcall Loaded();
	virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation);
	__property TABSDatabaseNotifyEvent OnDBNotify = {read=FOnDBNotify, write=FOnDBNotify};
	virtual void __fastcall SetName(const System::Classes::TComponentName NewName);
	
public:
	__fastcall virtual TABSSession(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TABSSession();
	void __fastcall LockSession();
	void __fastcall UnlockSession();
	void __fastcall Close();
	void __fastcall CloseDatabase(TABSDatabase* Database);
	void __fastcall DropConnections();
	TABSDatabase* __fastcall FindDatabase(const System::UnicodeString DatabaseName);
	void __fastcall GetDatabaseNames(System::Classes::TStrings* List);
	void __fastcall GetTableNames(const System::UnicodeString DatabaseName, System::Classes::TStrings* List);
	void __fastcall Open();
	TABSDatabase* __fastcall OpenDatabase(const System::UnicodeString DatabaseName);
	__property int DatabaseCount = {read=GetDatabaseCount, nodefault};
	__property TABSDatabase* Databases[int Index] = {read=GetDatabase};
	__property Absbase::TABSSessionComponentManager* Handle = {read=GetHandle};
	
__published:
	__property bool Active = {read=GetActive, write=SetActive, default=0};
	__property bool AutoSessionName = {read=FAutoSessionName, write=SetAutoSessionName, default=0};
	__property bool KeepConnections = {read=FKeepConnections, write=FKeepConnections, default=1};
	__property System::UnicodeString SessionName = {read=FSessionName, write=SetSessionName, stored=SessionNameStored};
	__property System::Classes::TNotifyEvent OnStartup = {read=FOnStartup, write=FOnStartup};
};


typedef System::Set<System::Int8, 0, 15> TABSDBFlags;

class PASCALIMPLEMENTATION TABSDataSet : public Data::Db::TDataSet
{
	typedef Data::Db::TDataSet inherited;
	
	
private:
	typedef System::DynamicArray<System::Word> _TABSDataSet__1;
	
	
private:
	System::UnicodeString FCurrentVersion;
	Absbase::TABSCursor* FHandle;
	System::UnicodeString FSessionName;
	System::Byte *FFilterBuffer;
	int FIndexFieldCount;
	_TABSDataSet__1 FIndexFieldMap;
	int FKeySize;
	TABSDBFlags FDBFlags;
	TABSDatabase* FDatabase;
	System::UnicodeString FDatabaseName;
	bool FInMemory;
	bool FReadOnly;
	bool FStoreDefs;
	System::Byte *FEditRecordBuffer;
	Absbase::TABSConstraintDefs* FABSConstraintDefs;
	Absbase::TABSCursor* FExternalHandle;
	Data::Db::TUpdateRecordEvent FOnUpdateRecord;
	
protected:
	Data::Db::TIndexDefs* FIndexDefs;
	Absbase::TABSFieldDefs* FABSFieldDefs;
	Absbase::TABSIndexDefs* FABSIndexDefs;
	TABSAdvIndexDefs* FAdvIndexDefs;
	TABSAdvFieldDefs* FAdvFieldDefs;
	TABSAdvIndexDefs* FRestructureIndexDefs;
	TABSAdvFieldDefs* FRestructureFieldDefs;
	System::StaticArray<System::PByte, 6> FKeyBuffers;
	System::Byte *FKeyBuffer;
	bool FIsRefreshing;
	bool FIgnoreDesignMode;
	virtual Data::Db::EUpdateError* __fastcall PSGetUpdateException(System::Sysutils::Exception* E, Data::Db::EUpdateError* Prev);
	virtual bool __fastcall PSIsSQLSupported();
	virtual void __fastcall PSReset();
	virtual bool __fastcall PSUpdateRecord(Data::Db::TUpdateKind UpdateKind, Data::Db::TDataSet* Delta);
	virtual void __fastcall PSStartTransaction();
	virtual void __fastcall PSEndTransaction(bool Commit);
	virtual void __fastcall PSGetAttributes(System::Classes::TList* List);
	virtual System::UnicodeString __fastcall PSGetQuoteChar();
	virtual bool __fastcall PSInTransaction();
	virtual bool __fastcall PSIsSQLBased();
	virtual int __fastcall PSExecuteStatement(const System::UnicodeString ASQL, Data::Db::TParams* AParams)/* overload */;
	virtual int __fastcall PSExecuteStatement(const System::UnicodeString ASQL, Data::Db::TParams* AParams, Data::Db::TDataSet* &ResultSet)/* overload */;
	System::PByte __fastcall InitKeyBuffer(System::PByte Buffer);
	void __fastcall AllocKeyBuffers();
	void __fastcall FreeKeyBuffers();
	bool __fastcall FieldDefsStored();
	bool __fastcall IndexDefsStored();
	void __fastcall SetIndexDefs(Data::Db::TIndexDefs* Value);
	System::PByte __fastcall GetActiveRecordBuffer();
	void __fastcall CheckDBSessionName();
	Absbase::TABSBaseSession* __fastcall GetDBHandle();
	TABSSession* __fastcall GetDBSession();
	void __fastcall CheckInMemoryDatabaseName();
	void __fastcall SetDatabaseName(const System::UnicodeString Value);
	void __fastcall SetSessionName(const System::UnicodeString Value);
	void __fastcall SetInMemory(const bool Value);
	System::UnicodeString __fastcall GetCurrentVersion();
	__property bool IgnoreDesignMode = {read=FIgnoreDesignMode, write=FIgnoreDesignMode, nodefault};
	virtual void __fastcall OpenCursor(bool InfoQuery);
	virtual void __fastcall CloseCursor();
	virtual void __fastcall Disconnect();
	virtual void __fastcall SetDBFlag(int Flag, bool Value);
	virtual Absbase::TABSCursor* __fastcall CreateHandle();
	virtual void __fastcall DestroyHandle();
	virtual bool __fastcall GetCanModify();
	void __fastcall DateTimeConvert(Data::Db::TField* Field, void * Source, void * Dest, bool ToNative);
	virtual void __fastcall DataConvert(Data::Db::TField* Field, void * Source, void * Dest, bool ToNative)/* overload */;
	virtual void __fastcall DataConvert(Data::Db::TField* Field, System::DynamicArray<System::Byte> Source, System::DynamicArray<System::Byte> &Dest, bool ToNative)/* overload */;
	virtual void __fastcall SetActive(bool Value);
	void __fastcall SwitchToIndex(const System::UnicodeString IndexName);
	virtual bool __fastcall GetIsIndexField(Data::Db::TField* Field);
	void __fastcall GetIndexInfo();
	bool __fastcall ResetCursorRange();
	virtual void __fastcall ClearCalcFields(System::PByte Buffer)/* overload */;
	virtual void __fastcall InternalRefresh();
	virtual Data::Db::TGetResult __fastcall GetRecord(System::PByte Buffer, Data::Db::TGetMode GetMode, bool DoCheck)/* overload */;
	
public:
	virtual bool __fastcall GetCurrentRecord(System::PByte Buffer)/* overload */;
	
protected:
	virtual int __fastcall GetRecordCount();
	virtual void __fastcall SetRecNo(int Value);
	virtual int __fastcall GetRecNo();
	virtual void __fastcall InternalFirst();
	virtual void __fastcall InternalLast();
	virtual void __fastcall InternalSetToRecord(System::PByte Buffer)/* overload */;
	virtual Data::Db::TBookmarkFlag __fastcall GetBookmarkFlag(System::PByte Buffer)/* overload */;
	virtual void __fastcall GetBookmarkData(System::PByte Buffer, void * Data)/* overload */;
	virtual void __fastcall GetBookmarkData(System::PByte Buffer, System::DynamicArray<System::Byte> Data)/* overload */;
	virtual void __fastcall InternalGotoBookmark(void * Bookmark)/* overload */;
	virtual void __fastcall SetBookmarkFlag(System::PByte Buffer, Data::Db::TBookmarkFlag Value)/* overload */;
	virtual void __fastcall SetBookmarkData(System::PByte Buffer, void * Data)/* overload */;
	virtual void __fastcall SetBookmarkData(System::PByte Buffer, System::DynamicArray<System::Byte> Data)/* overload */;
	
public:
	virtual int __fastcall CompareBookmarks(System::DynamicArray<System::Byte> Bookmark1, System::DynamicArray<System::Byte> Bookmark2);
	virtual bool __fastcall BookmarkValid(System::DynamicArray<System::Byte> Bookmark);
	
protected:
	bool __fastcall IsOnFilterRecordApplied();
	
public:
	bool __fastcall InternalFilterRecord(System::PByte Buffer);
	bool __fastcall FilterRecord(System::PByte Buffer, void * Dataset);
	
protected:
	virtual void __fastcall SetOnFilterRecord(const Data::Db::TFilterRecordEvent Value);
	bool __fastcall IsIndexApplied();
	virtual void __fastcall PrepareCursor();
	
public:
	void __fastcall SetSQLFilter(System::TObject* FilterExpr, System::TObject* ParentQueryAO, Absbase::TABSCursor* ParentCursor);
	void __fastcall ApplyProjection(System::Classes::TStringList* FieldNamesList, System::Classes::TStringList* AliasList);
	void __fastcall ActivateFilters();
	void __fastcall DeactivateFilters();
	void __fastcall SetFilterData(const System::UnicodeString Text, Data::Db::TFilterOptions Options);
	virtual void __fastcall SetFiltered(bool Value);
	virtual void __fastcall SetFilterOptions(Data::Db::TFilterOptions Value);
	virtual void __fastcall SetFilterText(const System::UnicodeString Value);
	virtual bool __fastcall FindRecord(bool Restart, bool GoForward);
	bool __fastcall LocateRecord(const System::UnicodeString KeyFields, const System::Variant &KeyValues, Data::Db::TLocateOptions Options);
	virtual bool __fastcall Locate(const System::UnicodeString KeyFields, const System::Variant &KeyValues, Data::Db::TLocateOptions Options);
	virtual System::Variant __fastcall Lookup(const System::UnicodeString KeyFields, const System::Variant &KeyValues, const System::UnicodeString ResultFields);
	
protected:
	virtual void __fastcall InitRecord(System::PByte Buffer)/* overload */;
	virtual void __fastcall InternalAddRecord(void * Buffer, bool Append)/* overload */;
	virtual void __fastcall InternalAddRecord(System::PByte Buffer, bool Append)/* overload */;
	virtual void __fastcall InternalInsert();
	virtual void __fastcall InternalEdit();
	virtual void __fastcall InternalCancel();
	virtual void __fastcall InternalPost();
	virtual void __fastcall InternalDelete();
	virtual void __fastcall InternalHandleException();
	virtual bool __fastcall IsCursorOpen();
	virtual void __fastcall InternalOpen();
	virtual void __fastcall InternalClose();
	virtual void __fastcall InternalInitFieldDefs();
	System::UnicodeString __fastcall CopyRecords(Data::Db::TDataSet* DestinationDataset);
	bool __fastcall InternalCopyRecords(Data::Db::TDataSet* SourceDataset, Data::Db::TDataSet* DestinationDataset, System::UnicodeString &Log, bool &Continue, bool IgnoreErrors = true, bool RestructuringTable = false, TABSProgressEvent ProgressEvent = 0x0, int MinProgress = 0x0, int MaxProgress = 0x64);
	virtual System::PByte __fastcall AllocRecordBuffer();
	virtual void __fastcall FreeRecordBuffer(System::PByte &Buffer);
	virtual void __fastcall InternalInitRecord(System::PByte Buffer)/* overload */;
	virtual System::Word __fastcall GetRecordSize();
	bool __fastcall IsRangeApplied();
	
public:
	bool __fastcall IsDistinctApplied();
	
protected:
	__property TABSDBFlags DBFlags = {read=FDBFlags, nodefault};
	
public:
	__fastcall virtual TABSDataSet(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TABSDataSet();
	TABSDatabase* __fastcall OpenDatabase();
	void __fastcall CloseDatabase(TABSDatabase* Database);
	virtual bool __fastcall GetFieldData(Data::Db::TField* Field, void * Buffer)/* overload */;
	virtual bool __fastcall GetFieldData(Data::Db::TField* Field, System::DynamicArray<System::Byte> &Buffer)/* overload */;
	
protected:
	virtual void __fastcall SetFieldData(Data::Db::TField* Field, void * Buffer)/* overload */;
	virtual void __fastcall SetFieldData(Data::Db::TField* Field, System::DynamicArray<System::Byte> Buffer)/* overload */;
	
public:
	HIDESBASE void __fastcall GetFieldValue(Absvariant::TABSVariant* Value, int FieldNo, bool DirectAccess);
	HIDESBASE void __fastcall SetFieldValue(Absvariant::TABSVariant* Value, int FieldNo, bool DirectAccess);
	void __fastcall CopyFieldValue(int SrcFieldNo, bool UseDirectFieldAccess, int DestFieldNo, TABSDataSet* DestDataset);
	
private:
	Abscompression::TABSStream* __fastcall InternalCreateBlobStream(Data::Db::TField* Field, Data::Db::TBlobStreamMode Mode);
	
public:
	virtual System::Classes::TStream* __fastcall CreateBlobStream(Data::Db::TField* Field, Data::Db::TBlobStreamMode Mode);
	virtual void __fastcall CloseBlob(Data::Db::TField* Field);
	void __fastcall GetDatabaseNameList(System::Classes::TStrings* List);
	__property Absbase::TABSCursor* Handle = {read=FHandle};
	__property TABSDatabase* Database = {read=FDatabase};
	__property TABSSession* DBSession = {read=GetDBSession};
	__property Data::Db::TIndexDefs* IndexDefs = {read=FIndexDefs, write=SetIndexDefs, stored=IndexDefsStored};
	__property FieldDefs = {stored=FieldDefsStored};
	__property TABSAdvIndexDefs* AdvIndexDefs = {read=FAdvIndexDefs};
	__property TABSAdvFieldDefs* AdvFieldDefs = {read=FAdvFieldDefs};
	__property int KeySize = {read=FKeySize, nodefault};
	__property bool StoreDefs = {read=FStoreDefs, write=FStoreDefs, default=0};
	
__published:
	__property System::UnicodeString CurrentVersion = {read=GetCurrentVersion, write=FCurrentVersion};
	__property System::UnicodeString DatabaseName = {read=FDatabaseName, write=SetDatabaseName};
	__property System::UnicodeString SessionName = {read=FSessionName, write=SetSessionName};
	__property bool InMemory = {read=FInMemory, write=SetInMemory, nodefault};
	__property bool ReadOnly = {read=FReadOnly, write=FReadOnly, nodefault};
	__property Active = {default=0};
	__property AutoCalcFields = {default=1};
	__property Filter = {default=0};
	__property Filtered = {default=0};
	__property FilterOptions = {default=0};
	__property BeforeOpen;
	__property AfterOpen;
	__property BeforeClose;
	__property AfterClose;
	__property BeforeInsert;
	__property AfterInsert;
	__property BeforeEdit;
	__property AfterEdit;
	__property BeforePost;
	__property AfterPost;
	__property BeforeCancel;
	__property AfterCancel;
	__property BeforeDelete;
	__property AfterDelete;
	__property BeforeScroll;
	__property AfterScroll;
	__property BeforeRefresh;
	__property AfterRefresh;
	__property OnCalcFields;
	__property OnDeleteError;
	__property OnEditError;
	__property OnFilterRecord;
	__property OnNewRecord;
	__property OnPostError;
	__property Data::Db::TUpdateRecordEvent OnUpdateRecord = {read=FOnUpdateRecord, write=FOnUpdateRecord};
	/* Hoisted overloads: */
	
protected:
	inline int __fastcall  PSExecuteStatement _DEPRECATED_ATTRIBUTE1("Use overloaded method instead") (const System::UnicodeString ASQL, Data::Db::TParams* AParams, void * ResultSet){ return Data::Db::TDataSet::PSExecuteStatement(ASQL, AParams, ResultSet); }
	inline void __fastcall  ClearCalcFields(NativeInt Buffer){ Data::Db::TDataSet::ClearCalcFields(Buffer); }
	inline Data::Db::TGetResult __fastcall  GetRecord(NativeInt Buffer, Data::Db::TGetMode GetMode, bool DoCheck){ return Data::Db::TDataSet::GetRecord(Buffer, GetMode, DoCheck); }
	
public:
	inline bool __fastcall  GetCurrentRecord(NativeInt Buffer){ return Data::Db::TDataSet::GetCurrentRecord(Buffer); }
	
protected:
	inline void __fastcall  InternalSetToRecord(NativeInt Buffer){ Data::Db::TDataSet::InternalSetToRecord(Buffer); }
	inline Data::Db::TBookmarkFlag __fastcall  GetBookmarkFlag(NativeInt Buffer){ return Data::Db::TDataSet::GetBookmarkFlag(Buffer); }
	inline void __fastcall  GetBookmarkData(NativeInt Buffer, System::DynamicArray<System::Byte> Data){ Data::Db::TDataSet::GetBookmarkData(Buffer, Data); }
	inline void __fastcall  InternalGotoBookmark(System::DynamicArray<System::Byte> Bookmark){ Data::Db::TDataSet::InternalGotoBookmark(Bookmark); }
	inline void __fastcall  SetBookmarkFlag(NativeInt Buffer, Data::Db::TBookmarkFlag Value){ Data::Db::TDataSet::SetBookmarkFlag(Buffer, Value); }
	inline void __fastcall  SetBookmarkData(NativeInt Buffer, System::DynamicArray<System::Byte> Data){ Data::Db::TDataSet::SetBookmarkData(Buffer, Data); }
	inline void __fastcall  InitRecord(NativeInt Buffer){ Data::Db::TDataSet::InitRecord(Buffer); }
	inline void __fastcall  InternalAddRecord(NativeInt Buffer, bool Append){ Data::Db::TDataSet::InternalAddRecord(Buffer, Append); }
	inline void __fastcall  InternalInitRecord(NativeInt Buffer){ Data::Db::TDataSet::InternalInitRecord(Buffer); }
	
public:
	inline bool __fastcall  GetFieldData(int FieldNo, System::DynamicArray<System::Byte> &Buffer){ return Data::Db::TDataSet::GetFieldData(FieldNo, Buffer); }
	inline bool __fastcall  GetFieldData(Data::Db::TField* Field, System::DynamicArray<System::Byte> &Buffer, bool NativeFormat){ return Data::Db::TDataSet::GetFieldData(Field, Buffer, NativeFormat); }
	inline bool __fastcall  GetFieldData _DEPRECATED_ATTRIBUTE1("Use overloaded method instead") (int FieldNo, void * Buffer){ return Data::Db::TDataSet::GetFieldData(FieldNo, Buffer); }
	inline bool __fastcall  GetFieldData _DEPRECATED_ATTRIBUTE1("Use overloaded method instead") (Data::Db::TField* Field, void * Buffer, bool NativeFormat){ return Data::Db::TDataSet::GetFieldData(Field, Buffer, NativeFormat); }
	
protected:
	inline void __fastcall  SetFieldData(Data::Db::TField* Field, System::DynamicArray<System::Byte> Buffer, bool NativeFormat){ Data::Db::TDataSet::SetFieldData(Field, Buffer, NativeFormat); }
	inline void __fastcall  SetFieldData _DEPRECATED_ATTRIBUTE1("Use overloaded method instead") (Data::Db::TField* Field, void * Buffer, bool NativeFormat){ Data::Db::TDataSet::SetFieldData(Field, Buffer, NativeFormat); }
	
};


#pragma pack(push,4)
class PASCALIMPLEMENTATION TABSExportToSqlOptions : public System::Classes::TPersistent
{
	typedef System::Classes::TPersistent inherited;
	
private:
	bool FStructure;
	bool FAddDropTable;
	bool FBlobSettings;
	bool FData;
	bool FFieldNamesInInserts;
	
public:
	__fastcall TABSExportToSqlOptions();
	virtual void __fastcall Assign(System::Classes::TPersistent* Source);
	
__published:
	__property bool Structure = {read=FStructure, write=FStructure, default=1};
	__property bool AddDropTable = {read=FAddDropTable, write=FAddDropTable, default=1};
	__property bool BlobSettings = {read=FBlobSettings, write=FBlobSettings, default=0};
	__property bool Data = {read=FData, write=FData, default=0};
	__property bool FieldNamesInInserts = {read=FFieldNamesInInserts, write=FFieldNamesInInserts, default=0};
public:
	/* TPersistent.Destroy */ inline __fastcall virtual ~TABSExportToSqlOptions() { }
	
};

#pragma pack(pop)

class PASCALIMPLEMENTATION TABSTable : public TABSDataSet
{
	typedef TABSDataSet inherited;
	
private:
	System::UnicodeString FTableName;
	bool FExclusive;
	bool FTemporary;
	System::UnicodeString FIndexName;
	bool FFieldsIndex;
	Data::Db::TMasterDataLink* FMasterLink;
	bool FDisableTempFiles;
	Absdlgwait::TfrmWait* frmWait;
	bool FIsRepairing;
	TABSDataSetNotifyEvent FBeforeCopy;
	TABSProgressEvent FOnCopyProgress;
	TABSDataSetNotifyEvent FAfterCopy;
	TABSDataSetNotifyEvent FBeforeImport;
	TABSProgressEvent FOnImportProgress;
	TABSDataSetNotifyEvent FAfterImport;
	TABSDataSetNotifyEvent FBeforeExport;
	TABSProgressEvent FOnExportProgress;
	TABSDataSetNotifyEvent FAfterExport;
	TABSDataSetNotifyEvent FBeforeRestructure;
	TABSProgressEvent FOnRestructureProgress;
	TABSDataSetNotifyEvent FAfterRestructure;
	TABSDataSetNotifyEvent FBeforeBatchMove;
	TABSProgressEvent FOnBatchMoveProgress;
	TABSDataSetNotifyEvent FAfterBatchMove;
	TABSExportToSqlOptions* FExportToSqlOptions;
	void __fastcall CheckBlankTableName();
	void __fastcall AutoCorrectAdvFieldDefs();
	void __fastcall AutoCorrectFieldDefs();
	void __fastcall CheckAdvFieldDefs();
	void __fastcall AutoCorrectAdvIndexDefs();
	void __fastcall SetTemporary(const bool Value);
	System::UnicodeString __fastcall GetIndexFieldNames();
	System::UnicodeString __fastcall GetIndexName();
	void __fastcall GetIndexParams(System::UnicodeString IndexName, bool FieldsIndex, System::UnicodeString &IndexedName);
	HIDESBASE bool __fastcall IndexDefsStored();
	void __fastcall SetIndex(const System::UnicodeString Value, bool FieldsIndex);
	void __fastcall SetIndexFieldNames(const System::UnicodeString Value);
	void __fastcall SetIndexName(const System::UnicodeString Value);
	void __fastcall SetTableName(const System::UnicodeString Value);
	
public:
	System::UnicodeString __fastcall FindOrCreateIndex(System::Classes::TStringList* FieldNamesList, System::Classes::TStringList* AscDescList, System::Classes::TStringList* CaseSensitivityList, bool &IsCreated);
	bool __fastcall IndexExists(System::Classes::TStringList* FieldNamesList, System::Classes::TStringList* AscDescList, System::Classes::TStringList* CaseSensitivityList);
	void __fastcall ApplyDistinct(System::Classes::TStringList* FieldNamesList, System::Classes::TStringList* AscDescList, System::Classes::TStringList* CaseSensitivityList)/* overload */;
	void __fastcall ApplyDistinct(TABSDataSet* ds)/* overload */;
	
private:
	bool __fastcall GetTableExists();
	void __fastcall CheckMasterRange();
	void __fastcall UpdateRange();
	void __fastcall MasterChanged(System::TObject* Sender);
	void __fastcall MasterDisabled(System::TObject* Sender);
	void __fastcall SetDataSource(Data::Db::TDataSource* Value);
	System::UnicodeString __fastcall GetMasterFields();
	void __fastcall SetMasterFields(const System::UnicodeString Value);
	
protected:
	virtual Data::Db::TIndexDef* __fastcall PSGetDefaultOrder();
	virtual System::UnicodeString __fastcall PSGetKeyFields();
	virtual System::UnicodeString __fastcall PSGetTableName();
	virtual Data::Db::TIndexDefs* __fastcall PSGetIndexDefs(Data::Db::TIndexOptions IndexTypes);
	virtual void __fastcall PSSetCommandText(const System::UnicodeString CommandText);
	virtual void __fastcall PSSetParams(Data::Db::TParams* AParams);
	virtual void __fastcall PrepareCursor();
	virtual Absbase::TABSCursor* __fastcall CreateHandle();
	virtual void __fastcall DataEvent(Data::Db::TDataEvent Event, NativeInt Info);
	virtual void __fastcall DefChanged(System::TObject* Sender);
	virtual void __fastcall InitFieldDefs();
	virtual void __fastcall DestroyHandle();
	Absbase::TABSCursor* __fastcall GetHandle();
	virtual void __fastcall UpdateIndexDefs();
	Data::Db::TField* __fastcall GetIndexField(int Index);
	void __fastcall SetIndexField(int Index, Data::Db::TField* Value);
	void __fastcall SetLinkRanges(System::Generics::Collections::TList__1<Data::Db::TField*>* MasterFields);
	virtual Data::Db::TDataSource* __fastcall GetDataSource();
	virtual void __fastcall DoOnNewRecord();
	int __fastcall GetIndexFieldCount();
	void __fastcall SetDefaultBlobFieldsValues();
	__property Data::Db::TMasterDataLink* MasterLink = {read=FMasterLink};
	
public:
	__fastcall virtual TABSTable(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TABSTable();
	void __fastcall CreateTable();
	void __fastcall DeleteTable();
	void __fastcall EmptyTable();
	void __fastcall RenameTable(System::UnicodeString NewTableName);
	bool __fastcall ImportTable(Data::Db::TDataSet* SourceTable, System::UnicodeString &Log, Data::Db::TIndexDefs* aIndexDefs = (Data::Db::TIndexDefs*)(0x0))/* overload */;
	bool __fastcall ImportTable(Data::Db::TDataSet* SourceTable)/* overload */;
	bool __fastcall ExportTable(Data::Db::TDataSet* DestinationTable, System::Sysutils::TProcedure CreateTablePointer, System::UnicodeString &Log)/* overload */;
	bool __fastcall ExportTable(Data::Db::TDataSet* DestinationTable, System::Sysutils::TProcedure CreateTablePointer)/* overload */;
	bool __fastcall CopyTable(System::UnicodeString NewTableName, System::UnicodeString &Log, bool &Continue, System::UnicodeString DestDatabaseFileName = System::UnicodeString(), System::UnicodeString DestDatabasePassword = System::UnicodeString(), bool IgnoreErrors = false, bool OverwriteExistingTable = false, bool CopyIndexes = true, int MinProgress = 0x0, int MaxProgress = 0x64)/* overload */;
	void __fastcall CopyTable(System::UnicodeString NewTableName, System::UnicodeString DestDatabaseFileName = System::UnicodeString(), System::UnicodeString DestDatabasePassword = System::UnicodeString())/* overload */;
	void __fastcall BatchMove(TABSDataSet* SourceTableOrQuery, Abstypes::TABSBatchMoveType MoveType, System::UnicodeString DstTableIndexNameToIdentifyEqualRecords = System::UnicodeString());
	bool __fastcall RestructureTable(System::UnicodeString &Log)/* overload */;
	bool __fastcall RestructureTable()/* overload */;
	System::UnicodeString __fastcall ExportToSQL()/* overload */;
	void __fastcall ExportToSQL(System::Classes::TStream* Stream)/* overload */;
	void __fastcall ExportToSQL(System::UnicodeString FileName)/* overload */;
	void __fastcall RenameField(System::UnicodeString FieldName, System::UnicodeString NewFieldName)/* overload */;
	void __fastcall AddIndex(const System::UnicodeString Name, const System::UnicodeString Fields, Data::Db::TIndexOptions Options, const System::UnicodeString DescFields = System::UnicodeString(), const System::UnicodeString CaseInsFields = System::UnicodeString());
	void __fastcall DeleteIndex(const System::UnicodeString Name);
	void __fastcall DeleteAllIndexes();
	
protected:
	void __fastcall ValidateAndRepairMostUpdatedAndRecordPageIndex();
	void __fastcall CheckSetKeyMode();
	System::PByte __fastcall GetKeyBuffer(Abstypes::TABSKeyIndex KeyIndex);
	bool __fastcall GetKeyExclusive();
	int __fastcall GetKeyFieldCount();
	void __fastcall SetKeyExclusive(bool Value);
	void __fastcall SetKeyFieldCount(int Value);
	void __fastcall SetKeyBuffer(Abstypes::TABSKeyIndex KeyIndex, bool Clear);
	void __fastcall SetKeyFields(Abstypes::TABSKeyIndex KeyIndex, const System::TVarRec *Values, const int Values_High);
	void __fastcall PostKeyBuffer(bool Commit);
	
public:
	bool __fastcall FindKey(const System::TVarRec *KeyValues, const int KeyValues_High);
	void __fastcall FindNearest(const System::TVarRec *KeyValues, const int KeyValues_High);
	bool __fastcall GotoKey();
	void __fastcall GotoNearest();
	void __fastcall EditKey();
	void __fastcall SetKey();
	bool __fastcall SetCursorRange();
	void __fastcall ApplyRange();
	void __fastcall CancelRange();
	void __fastcall EditRangeStart();
	void __fastcall EditRangeEnd();
	void __fastcall SetRange(const System::TVarRec *StartValues, const int StartValues_High, const System::TVarRec *EndValues, const int EndValues_High);
	void __fastcall SetRangeStart();
	void __fastcall SetRangeEnd();
	virtual void __fastcall Post();
	virtual void __fastcall Cancel();
	bool __fastcall IsRecordLocked();
	__int64 __fastcall LastAutoincValue(int FieldIndex)/* overload */;
	__int64 __fastcall LastAutoincValue(System::UnicodeString FieldName)/* overload */;
	void __fastcall InternalBeforeCopy(System::TObject* Sender);
	void __fastcall InternalOnCopyProgress(System::TObject* Sender, int PercentDone, bool &Continue);
	void __fastcall InternalAfterCopy(System::TObject* Sender);
	void __fastcall InternalBeforeImport(System::TObject* Sender);
	void __fastcall InternalOnImportProgress(System::TObject* Sender, int PercentDone, bool &Continue);
	void __fastcall InternalAfterImport(System::TObject* Sender);
	void __fastcall InternalBeforeExport(System::TObject* Sender);
	void __fastcall InternalOnExportProgress(System::TObject* Sender, int PercentDone, bool &Continue);
	void __fastcall InternalAfterExport(System::TObject* Sender);
	void __fastcall InternalBeforeRestructure(System::TObject* Sender);
	void __fastcall InternalOnRestructureProgress(System::TObject* Sender, int PercentDone, bool &Continue);
	void __fastcall InternalAfterRestructure(System::TObject* Sender);
	void __fastcall InternalBeforeBatchMove(System::TObject* Sender);
	void __fastcall InternalOnBatchMoveProgress(System::TObject* Sender, int PercentDone, bool &Continue);
	void __fastcall InternalAfterBatchMove(System::TObject* Sender);
	__property int IndexFieldCount = {read=GetIndexFieldCount, nodefault};
	__property Data::Db::TField* IndexFields[int Index] = {read=GetIndexField, write=SetIndexField};
	__property bool KeyExclusive = {read=GetKeyExclusive, write=SetKeyExclusive, nodefault};
	__property int KeyFieldCount = {read=GetKeyFieldCount, write=SetKeyFieldCount, nodefault};
	__property bool Temporary = {read=FTemporary, write=SetTemporary, nodefault};
	__property TABSAdvIndexDefs* RestructureIndexDefs = {read=FRestructureIndexDefs};
	__property TABSAdvFieldDefs* RestructureFieldDefs = {read=FRestructureFieldDefs};
	__property bool DisableTempFiles = {read=FDisableTempFiles, write=FDisableTempFiles, nodefault};
	
__published:
	__property StoreDefs = {default=0};
	__property Data::Db::TIndexDefs* IndexDefs = {read=FIndexDefs, write=SetIndexDefs, stored=IndexDefsStored};
	__property System::UnicodeString IndexFieldNames = {read=GetIndexFieldNames, write=SetIndexFieldNames};
	__property System::UnicodeString IndexName = {read=GetIndexName, write=SetIndexName};
	__property FieldDefs = {stored=FieldDefsStored};
	__property System::UnicodeString TableName = {read=FTableName, write=SetTableName};
	__property bool Exclusive = {read=FExclusive, write=FExclusive, nodefault};
	__property bool Exists = {read=GetTableExists, nodefault};
	__property System::UnicodeString MasterFields = {read=GetMasterFields, write=SetMasterFields};
	__property Data::Db::TDataSource* MasterSource = {read=GetDataSource, write=SetDataSource};
	__property TABSExportToSqlOptions* ExportToSqlOptions = {read=FExportToSqlOptions, write=FExportToSqlOptions};
	__property TABSDataSetNotifyEvent BeforeCopy = {read=FBeforeCopy, write=FBeforeCopy};
	__property TABSProgressEvent OnCopyProgress = {read=FOnCopyProgress, write=FOnCopyProgress};
	__property TABSDataSetNotifyEvent AfterCopy = {read=FAfterCopy, write=FAfterCopy};
	__property TABSDataSetNotifyEvent BeforeImport = {read=FBeforeImport, write=FBeforeImport};
	__property TABSProgressEvent OnImportProgress = {read=FOnImportProgress, write=FOnImportProgress};
	__property TABSDataSetNotifyEvent AfterImport = {read=FAfterImport, write=FAfterImport};
	__property TABSDataSetNotifyEvent BeforeExport = {read=FBeforeExport, write=FBeforeExport};
	__property TABSProgressEvent OnExportProgress = {read=FOnExportProgress, write=FOnExportProgress};
	__property TABSDataSetNotifyEvent AfterExport = {read=FAfterExport, write=FAfterExport};
	__property TABSDataSetNotifyEvent BeforeRestructure = {read=FBeforeRestructure, write=FBeforeRestructure};
	__property TABSProgressEvent OnRestructureProgress = {read=FOnRestructureProgress, write=FOnRestructureProgress};
	__property TABSDataSetNotifyEvent AfterRestructure = {read=FAfterRestructure, write=FAfterRestructure};
	__property TABSDataSetNotifyEvent BeforeBatchMove = {read=FBeforeBatchMove, write=FBeforeBatchMove};
	__property TABSProgressEvent OnBatchMoveProgress = {read=FOnBatchMoveProgress, write=FOnBatchMoveProgress};
	__property TABSDataSetNotifyEvent AfterBatchMove = {read=FAfterBatchMove, write=FAfterBatchMove};
};


class PASCALIMPLEMENTATION TABSQuery : public TABSDataSet
{
	typedef TABSDataSet inherited;
	
private:
	Abssqlprocessor::TABSSQLProcessor* FStmtHandle;
	System::Classes::TStrings* FSQL;
	bool FPrepared;
	Data::Db::TParams* FParams;
	System::UnicodeString FText;
	Data::Db::TDataLink* FDataLink;
	int FRowsAffected;
	bool FRequestLive;
	char *FSQLBinary;
	bool FParamCheck;
	bool FExecSQL;
	bool FCheckRowsAffected;
	
protected:
	virtual void __fastcall PSExecute();
	virtual Data::Db::TIndexDef* __fastcall PSGetDefaultOrder();
	virtual Data::Db::TParams* __fastcall PSGetParams();
	virtual System::UnicodeString __fastcall PSGetTableName();
	virtual void __fastcall PSSetCommandText(const System::UnicodeString CommandText);
	virtual void __fastcall PSSetParams(Data::Db::TParams* AParams);
	void __fastcall GetStatementHandle(System::WideChar * SQLText);
	void __fastcall FreeStatement();
	Absbase::TABSCursor* __fastcall CreateCursor(bool GenHandle);
	Absbase::TABSCursor* __fastcall GetQueryCursor(bool GenHandle);
	int __fastcall GetRowsAffected();
	void __fastcall QueryChanged(System::TObject* Sender);
	virtual Data::Db::TDataSource* __fastcall GetDataSource();
	void __fastcall SetDataSource(Data::Db::TDataSource* Value);
	void __fastcall SetQuery(System::Classes::TStrings* Value);
	virtual void __fastcall InternalRefresh();
	System::Word __fastcall GetParamsCount();
	void __fastcall RefreshParams();
	void __fastcall SetParamsList(Data::Db::TParams* Value);
	void __fastcall SetParamsFromCursor();
	
public:
	Data::Db::TParam* __fastcall ParamByName(const System::UnicodeString Value);
	void __fastcall Prepare();
	void __fastcall UnPrepare();
	
protected:
	void __fastcall PrepareSQL(System::WideChar * Value);
	void __fastcall SetPrepared(bool Value);
	void __fastcall SetPrepare(bool Value);
	virtual void __fastcall DefineProperties(System::Classes::TFiler* Filer);
	void __fastcall ReadBinaryData(System::Classes::TStream* Stream);
	void __fastcall WriteBinaryData(System::Classes::TStream* Stream);
	void __fastcall ReadParamData(System::Classes::TReader* Reader);
	void __fastcall WriteParamData(System::Classes::TWriter* Writer);
	virtual Absbase::TABSCursor* __fastcall CreateHandle();
	virtual void __fastcall Disconnect();
	virtual void __fastcall SetDBFlag(int Flag, bool Value);
	
public:
	__fastcall virtual TABSQuery(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TABSQuery();
	void __fastcall ExecSQL();
	virtual void __fastcall GetDetailLinkFields(System::Classes::TList* MasterFields, System::Classes::TList* DetailFields)/* overload */;
	__property bool Prepared = {read=FPrepared, write=SetPrepare, nodefault};
	__property System::Word ParamCount = {read=GetParamsCount, nodefault};
	__property Abssqlprocessor::TABSSQLProcessor* StmtHandle = {read=FStmtHandle};
	__property System::UnicodeString Text = {read=FText};
	__property int RowsAffected = {read=GetRowsAffected, nodefault};
	__property char * SQLBinary = {read=FSQLBinary, write=FSQLBinary};
	
__published:
	__property Data::Db::TDataSource* DataSource = {read=GetDataSource, write=SetDataSource};
	__property bool ParamCheck = {read=FParamCheck, write=FParamCheck, default=1};
	__property bool RequestLive = {read=FRequestLive, write=FRequestLive, default=0};
	__property System::Classes::TStrings* SQL = {read=FSQL, write=SetQuery};
	__property Data::Db::TParams* Params = {read=FParams, write=SetParamsList, stored=false};
	/* Hoisted overloads: */
	
public:
	inline void __fastcall  GetDetailLinkFields(System::Generics::Collections::TList__1<Data::Db::TField*>* MasterFields, System::Generics::Collections::TList__1<Data::Db::TField*>* DetailFields){ Data::Db::TDataSet::GetDetailLinkFields(MasterFields, DetailFields); }
	
};


typedef void __fastcall (__closure *TABSOnNeedRepairEvent)(System::TObject* Sender, bool &DoRepair);

class PASCALIMPLEMENTATION TABSDatabase : public System::Classes::TComponent
{
	typedef System::Classes::TComponent inherited;
	
private:
	System::UnicodeString FCurrentVersion;
	System::Classes::TList* FDataSets;
	bool FKeepConnection;
	bool FTemporary;
	bool FStreamedConnected;
	bool FAcquiredHandle;
	bool FHandleShared;
	bool FReadOnly;
	bool FExclusive;
	int FRefCount;
	Absbase::TABSBaseSession* FHandle;
	TABSSession* FSession;
	System::UnicodeString FSessionName;
	System::UnicodeString FDatabaseName;
	System::UnicodeString FDatabaseFileName;
	System::UnicodeString FPassword;
	Abssecurity::TABSCryptoAlgorithm FCryptoAlgorithm;
	int FPageSize;
	int FPageCountInExtent;
	bool FNoRequestAutoRepair;
	bool FSilentMode;
	bool FMultiUser;
	int FMaxConnections;
	bool FDisableTempFiles;
	TABSPasswordEvent FOnPassword;
	System::Classes::TNotifyEvent FBeforeRepair;
	TABSProgressEvent FOnRepairProgress;
	System::Classes::TNotifyEvent FAfterRepair;
	System::Classes::TNotifyEvent FBeforeCompact;
	TABSProgressEvent FOnCompactProgress;
	System::Classes::TNotifyEvent FAfterCompact;
	System::Classes::TNotifyEvent FBeforeChangePassword;
	TABSProgressEvent FOnChangePasswordProgress;
	System::Classes::TNotifyEvent FAfterChangePassword;
	System::Classes::TNotifyEvent FAfterChangeDatabaseSettings;
	TABSProgressEvent FOnChangeDatabaseSettingsProgress;
	System::Classes::TNotifyEvent FBeforeChangeDatabaseSettings;
	TABSOnNeedRepairEvent FOnNeedRepair;
	Absdlgwait::TfrmWait* frmWait;
	void __fastcall CheckActive();
	void __fastcall CheckInactive();
	void __fastcall CheckDatabaseName();
	void __fastcall CheckSessionName(bool Required);
	void __fastcall CheckConnected();
	bool __fastcall GetConnected();
	TABSDataSet* __fastcall GetDataSet(int Index);
	int __fastcall GetDataSetCount();
	bool __fastcall OpenFromExistingDB();
	void __fastcall SetDatabaseFileName(System::UnicodeString Value);
	void __fastcall SetDatabaseName(System::UnicodeString Value);
	void __fastcall SetHandle(Absbase::TABSBaseSession* Value);
	void __fastcall SetKeepConnection(bool Value);
	void __fastcall SetReadOnly(bool Value);
	void __fastcall SetSessionName(const System::UnicodeString Value);
	void __fastcall SetConnected(bool value);
	bool __fastcall GetExists();
	void __fastcall CreateHandle();
	void __fastcall DestroyHandle();
	bool __fastcall GetPassword();
	bool __fastcall GetInTransaction();
	System::UnicodeString __fastcall GetCurrentVersion();
	void __fastcall DoOnNeedRepair(bool &DoRepair);
	void __fastcall DoOnNeedConvert(bool &DoRepair);
	bool __fastcall InternalCopyDatabase(System::UnicodeString NewDatabaseFileName, System::UnicodeString &Log, bool IgnoreErrors = false, System::UnicodeString NewPassword = System::UnicodeString(), Abssecurity::TABSCryptoAlgorithm NewCryptoAlgorithm = (Abssecurity::TABSCryptoAlgorithm)(0x0), int NewPageSize = 0x1000, int NewPageCountInExtent = 0x8, int NewMaxConnections = 0x1f4, System::Classes::TNotifyEvent BeforeEvent = 0x0, TABSProgressEvent ProgressEvent = 0x0, System::Classes::TNotifyEvent AfterEvent = 0x0);
	void __fastcall EmptyEvent(System::TObject* Sender);
	void __fastcall InternalBeforeRepair(System::TObject* Sender);
	void __fastcall InternalOnRepairProgress(System::TObject* Sender, int PercentDone, bool &Continue);
	void __fastcall InternalAfterRepair(System::TObject* Sender);
	void __fastcall InternalBeforeCompact(System::TObject* Sender);
	void __fastcall InternalOnCompactProgress(System::TObject* Sender, int PercentDone, bool &Continue);
	void __fastcall InternalAfterCompact(System::TObject* Sender);
	void __fastcall InternalBeforeChangePassword(System::TObject* Sender);
	void __fastcall InternalOnChangePasswordProgress(System::TObject* Sender, int PercentDone, bool &Continue);
	void __fastcall InternalAfterChangePassword(System::TObject* Sender);
	void __fastcall InternalBeforeChangeDatabaseSettings(System::TObject* Sender);
	void __fastcall InternalOnChangeDatabaseSettingsProgress(System::TObject* Sender, int PercentDone, bool &Continue);
	void __fastcall InternalAfterChangeDatabaseSettings(System::TObject* Sender);
	
protected:
	virtual void __fastcall Loaded();
	virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation);
	
public:
	__fastcall virtual TABSDatabase(System::Classes::TComponent* AOwner);
	__fastcall virtual ~TABSDatabase();
	void __fastcall Open();
	void __fastcall Close();
	void __fastcall CreateDatabase();
	void __fastcall DeleteDatabase();
	void __fastcall RenameDatabase(System::UnicodeString NewDatabaseFileName);
	bool __fastcall CompactDatabase(System::UnicodeString NewDatabaseFileName)/* overload */;
	bool __fastcall CompactDatabase()/* overload */;
	void __fastcall TruncateDatabase();
	System::UnicodeString __fastcall RepairDatabase()/* overload */;
	bool __fastcall RepairDatabase(System::UnicodeString NewDatabaseFileName, System::UnicodeString &Log)/* overload */;
	bool __fastcall ChangeDatabaseSettings(System::UnicodeString &Log, bool IgnoreErrors, System::UnicodeString NewPassword, Abssecurity::TABSCryptoAlgorithm NewCryptoAlgorithm = (Abssecurity::TABSCryptoAlgorithm)(0x0), int NewPageSize = 0x1000, int NewPageCountInExtent = 0x8, int NewMaxConnections = 0x1f4);
	System::UnicodeString __fastcall ChangePassword(System::UnicodeString NewPassword)/* overload */;
	System::UnicodeString __fastcall ChangePassword(System::UnicodeString NewPassword, Abssecurity::TABSCryptoAlgorithm NewCryptoAlgorithm)/* overload */;
	void __fastcall MakeExecutableDatabase(const System::UnicodeString ExeStubFileName, const System::UnicodeString ExeDbFileName);
	int __fastcall GetDBFileConnectionsCount();
	void __fastcall FlushBuffers();
	void __fastcall CloseDataSets();
	void __fastcall ValidateName(const System::UnicodeString Name);
	void __fastcall GetTablesList(System::Classes::TStrings* List);
	bool __fastcall TableExists(System::UnicodeString TableName);
	void __fastcall StartTransaction();
	void __fastcall Commit(bool DoFlushBuffers = true);
	void __fastcall Rollback();
	__property TABSDataSet* DataSets[int Index] = {read=GetDataSet};
	__property int DataSetCount = {read=GetDataSetCount, nodefault};
	__property bool Exists = {read=GetExists, nodefault};
	__property Absbase::TABSBaseSession* Handle = {read=FHandle, write=SetHandle};
	__property TABSSession* Session = {read=FSession};
	__property bool Temporary = {read=FTemporary, write=FTemporary, nodefault};
	__property bool InTransaction = {read=GetInTransaction, nodefault};
	__property int PageSize = {read=FPageSize, write=FPageSize, nodefault};
	__property int PageCountInExtent = {read=FPageCountInExtent, write=FPageCountInExtent, nodefault};
	__property Abssecurity::TABSCryptoAlgorithm CryptoAlgorithm = {read=FCryptoAlgorithm, write=FCryptoAlgorithm, nodefault};
	
__published:
	__property bool Connected = {read=GetConnected, write=SetConnected, default=0};
	__property System::UnicodeString CurrentVersion = {read=GetCurrentVersion, write=FCurrentVersion};
	__property System::UnicodeString DatabaseFileName = {read=FDatabaseFileName, write=SetDatabaseFileName};
	__property System::UnicodeString DatabaseName = {read=FDatabaseName, write=SetDatabaseName};
	__property bool Exclusive = {read=FExclusive, write=FExclusive, nodefault};
	__property System::UnicodeString Password = {read=FPassword, write=FPassword};
	__property bool ReadOnly = {read=FReadOnly, write=SetReadOnly, default=0};
	__property bool HandleShared = {read=FHandleShared, write=FHandleShared, default=0};
	__property bool KeepConnection = {read=FKeepConnection, write=SetKeepConnection, default=1};
	__property int MaxConnections = {read=FMaxConnections, write=FMaxConnections, nodefault};
	__property bool MultiUser = {read=FMultiUser, write=FMultiUser, nodefault};
	__property System::UnicodeString SessionName = {read=FSessionName, write=SetSessionName};
	__property bool SilentMode = {read=FSilentMode, write=FSilentMode, default=0};
	__property bool DisableTempFiles = {read=FDisableTempFiles, write=FDisableTempFiles, default=0};
	__property TABSPasswordEvent OnPassword = {read=FOnPassword, write=FOnPassword};
	__property System::Classes::TNotifyEvent BeforeRepair = {read=FBeforeRepair, write=FBeforeRepair};
	__property TABSProgressEvent OnRepairProgress = {read=FOnRepairProgress, write=FOnRepairProgress};
	__property System::Classes::TNotifyEvent AfterRepair = {read=FAfterRepair, write=FAfterRepair};
	__property System::Classes::TNotifyEvent BeforeCompact = {read=FBeforeCompact, write=FBeforeCompact};
	__property TABSProgressEvent OnCompactProgress = {read=FOnCompactProgress, write=FOnCompactProgress};
	__property System::Classes::TNotifyEvent AfterCompact = {read=FAfterCompact, write=FAfterCompact};
	__property System::Classes::TNotifyEvent BeforeChangePassword = {read=FBeforeChangePassword, write=FBeforeChangePassword};
	__property TABSProgressEvent OnChangePasswordProgress = {read=FOnChangePasswordProgress, write=FOnChangePasswordProgress};
	__property System::Classes::TNotifyEvent AfterChangePassword = {read=FAfterChangePassword, write=FAfterChangePassword};
	__property TABSOnNeedRepairEvent OnNeedRepair = {read=FOnNeedRepair, write=FOnNeedRepair};
	__property System::Classes::TNotifyEvent BeforeChangeDatabaseSettings = {read=FBeforeChangeDatabaseSettings, write=FBeforeChangeDatabaseSettings};
	__property TABSProgressEvent OnChangeDatabaseSettingsProgress = {read=FOnChangeDatabaseSettingsProgress, write=FOnChangeDatabaseSettingsProgress};
	__property System::Classes::TNotifyEvent AfterChangeDatabaseSettings = {read=FAfterChangeDatabaseSettings, write=FAfterChangeDatabaseSettings};
};


class PASCALIMPLEMENTATION TABSAdvFieldDef : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::UnicodeString FName;
	int FObjectID;
	Abstypes::TABSAdvancedFieldType FDataType;
	bool FRequired;
	int FSize;
	Absvariant::TABSVariant* FDefaultValue;
	Absvariant::TABSVariant* FMinValue;
	Absvariant::TABSVariant* FMaxValue;
	__int64 FAutoincIncrement;
	__int64 FAutoincInitialValue;
	__int64 FAutoincMinValue;
	__int64 FAutoincMaxValue;
	bool FAutoincCycled;
	TCompressionAlgorithm FBLOBCompressionAlgorithm;
	System::Byte FBLOBCompressionMode;
	int FBLOBBlockSize;
	
public:
	void __fastcall Assign(TABSAdvFieldDef* Source);
	__fastcall TABSAdvFieldDef();
	__fastcall virtual ~TABSAdvFieldDef();
	__property System::UnicodeString Name = {read=FName, write=FName};
	__property int ObjectID = {read=FObjectID, write=FObjectID, nodefault};
	__property Abstypes::TABSAdvancedFieldType DataType = {read=FDataType, write=FDataType, nodefault};
	__property bool Required = {read=FRequired, write=FRequired, nodefault};
	__property int Size = {read=FSize, write=FSize, nodefault};
	__property Absvariant::TABSVariant* DefaultValue = {read=FDefaultValue};
	__property Absvariant::TABSVariant* MinValue = {read=FMinValue};
	__property Absvariant::TABSVariant* MaxValue = {read=FMaxValue};
	__property __int64 AutoincIncrement = {read=FAutoincIncrement, write=FAutoincIncrement};
	__property __int64 AutoincInitialValue = {read=FAutoincInitialValue, write=FAutoincInitialValue};
	__property __int64 AutoincMinValue = {read=FAutoincMinValue, write=FAutoincMinValue};
	__property __int64 AutoincMaxValue = {read=FAutoincMaxValue, write=FAutoincMaxValue};
	__property bool AutoincCycled = {read=FAutoincCycled, write=FAutoincCycled, nodefault};
	__property TCompressionAlgorithm BLOBCompressionAlgorithm = {read=FBLOBCompressionAlgorithm, write=FBLOBCompressionAlgorithm, nodefault};
	__property System::Byte BLOBCompressionMode = {read=FBLOBCompressionMode, write=FBLOBCompressionMode, nodefault};
	__property int BLOBBlockSize = {read=FBLOBBlockSize, write=FBLOBBlockSize, nodefault};
};


#pragma pack(push,4)
class PASCALIMPLEMENTATION TABSAdvFieldDefs : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	TABSAdvFieldDef* operator[](int Index) { return this->Items[Index]; }
	
private:
	System::Classes::TList* FDefsList;
	int __fastcall GetCount();
	TABSAdvFieldDef* __fastcall GetDef(int Index);
	void __fastcall SetDef(int Index, TABSAdvFieldDef* value);
	
public:
	void __fastcall Assign(TABSAdvFieldDefs* Source);
	__fastcall TABSAdvFieldDefs();
	__fastcall virtual ~TABSAdvFieldDefs();
	TABSAdvFieldDef* __fastcall AddFieldDef();
	void __fastcall Add(const System::UnicodeString Name, Abstypes::TABSAdvancedFieldType DataType, int Size = 0x0, bool Required = false, TCompressionAlgorithm BLOBCompressionAlgorithm = (TCompressionAlgorithm)(0x0), System::Byte BLOBCompressionMode = (System::Byte)(0x0));
	void __fastcall DeleteFieldDef(const System::UnicodeString FieldName);
	TABSAdvFieldDef* __fastcall Find(const System::UnicodeString Name);
	void __fastcall Clear();
	__property TABSAdvFieldDef* Items[int Index] = {read=GetDef, write=SetDef/*, default*/};
	__property int Count = {read=GetCount, nodefault};
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TABSAdvIndexDef : public System::TObject
{
	typedef System::TObject inherited;
	
private:
	System::UnicodeString FName;
	System::UnicodeString FFields;
	System::UnicodeString FDescFields;
	System::UnicodeString FCaseInsFields;
	Data::Db::TIndexOptions FOptions;
	System::UnicodeString FMaxIndexedSizes;
	bool FTemporary;
	
public:
	__fastcall TABSAdvIndexDef();
	void __fastcall Assign(TABSAdvIndexDef* ASource);
	
__published:
	__property System::UnicodeString Name = {read=FName, write=FName};
	__property System::UnicodeString CaseInsFields = {read=FCaseInsFields, write=FCaseInsFields};
	__property System::UnicodeString DescFields = {read=FDescFields, write=FDescFields};
	__property System::UnicodeString Fields = {read=FFields, write=FFields};
	__property Data::Db::TIndexOptions Options = {read=FOptions, write=FOptions, default=0};
	__property bool Temporary = {read=FTemporary, write=FTemporary, nodefault};
	__property System::UnicodeString MaxIndexedSizes = {read=FMaxIndexedSizes, write=FMaxIndexedSizes};
public:
	/* TObject.Destroy */ inline __fastcall virtual ~TABSAdvIndexDef() { }
	
};

#pragma pack(pop)

#pragma pack(push,4)
class PASCALIMPLEMENTATION TABSAdvIndexDefs : public System::TObject
{
	typedef System::TObject inherited;
	
public:
	TABSAdvIndexDef* operator[](int Index) { return this->Items[Index]; }
	
private:
	System::Classes::TList* FDefsList;
	Data::Db::TDataSet* FDataset;
	int __fastcall GetCount();
	TABSAdvIndexDef* __fastcall GetDef(int Index);
	void __fastcall SetDef(int Index, TABSAdvIndexDef* value);
	
public:
	void __fastcall Assign(TABSAdvIndexDefs* Source, bool SkipTemporaryIndexes = false);
	__fastcall TABSAdvIndexDefs(Data::Db::TDataSet* ADataSet);
	__fastcall virtual ~TABSAdvIndexDefs();
	TABSAdvIndexDef* __fastcall AddIndexDef();
	void __fastcall Add(const System::UnicodeString Name, const System::UnicodeString Fields, Data::Db::TIndexOptions Options, bool Temporary = false, System::UnicodeString DescFields = System::UnicodeString(), System::UnicodeString CaseInsFields = System::UnicodeString(), System::UnicodeString MaxIndexedSizes = System::UnicodeString());
	void __fastcall DeleteIndexDef(const System::UnicodeString IndexName);
	TABSAdvIndexDef* __fastcall Find(const System::UnicodeString Name);
	void __fastcall Clear();
	void __fastcall Update();
	__property TABSAdvIndexDef* Items[int Index] = {read=GetDef, write=SetDef/*, default*/};
	__property int Count = {read=GetCount, nodefault};
};

#pragma pack(pop)

//-- var, const, procedure ---------------------------------------------------
extern DELPHI_PACKAGE bool StartDisconnected;
static const System::Int8 dbfOpened = System::Int8(0x0);
static const System::Int8 dbfPrepared = System::Int8(0x1);
static const System::Int8 dbfExecSQL = System::Int8(0x2);
static const System::Int8 dbfTable = System::Int8(0x3);
static const System::Int8 dbfFieldList = System::Int8(0x4);
static const System::Int8 dbfIndexList = System::Int8(0x5);
static const System::Int8 dbfStoredProc = System::Int8(0x6);
static const System::Int8 dbfExecProc = System::Int8(0x7);
static const System::Int8 dbfProcDesc = System::Int8(0x8);
static const System::Int8 dbfDatabase = System::Int8(0x9);
static const System::Int8 dbfProvider = System::Int8(0xa);
static const System::Int8 dbfRepair = System::Int8(0xb);
extern DELPHI_PACKAGE TABSSessionList* Sessions;
extern DELPHI_PACKAGE TABSSession* Session;
extern DELPHI_PACKAGE bool IsIDERunning;
extern DELPHI_PACKAGE bool IsDelphiOrBuilderInstalled;
extern DELPHI_PACKAGE bool IsNagScreenShown;
extern DELPHI_PACKAGE void __fastcall ConvertFieldDefsToABSFieldDefs(Data::Db::TFieldDefs* FieldDefs, Absbase::TABSFieldDefs* ABSFieldDefs);
extern DELPHI_PACKAGE void __fastcall ConvertAdvFieldDefsToFieldDefs(TABSAdvFieldDefs* AdvFieldDefs, Data::Db::TFieldDefs* FieldDefs);
extern DELPHI_PACKAGE void __fastcall ConvertFieldDefsToAdvFieldDefs(Data::Db::TFieldDefs* FieldDefs, TABSAdvFieldDefs* AdvFieldDefs);
extern DELPHI_PACKAGE void __fastcall ConvertAdvFieldDefsToABSFieldDefs(TABSAdvFieldDefs* AdvFieldDefs, Absbase::TABSFieldDefs* ABSFieldDefs, Absbase::TABSIndexDefs* IndexDefs, Absbase::TABSConstraintDefs* ABSConstraintDefs, bool Temporary);
extern DELPHI_PACKAGE Absbase::TABSConstraintDef* __fastcall AddConstraintForIndex(Absbase::TABSIndexDef* IndexDef, Absbase::TABSConstraintDefs* ABSConstraintDefs);
extern DELPHI_PACKAGE void __fastcall ConvertABSFieldDefsToAdvFieldDefs(Absbase::TABSFieldDefs* VisibleFieldDefs, Absbase::TABSFieldDefs* ABSFieldDefs, Absbase::TABSConstraintDefs* ABSConstraintDefs, TABSAdvFieldDefs* AdvFieldDefs);
extern DELPHI_PACKAGE void __fastcall ConvertABSFieldDefsToFieldDefs(Absbase::TABSFieldDefs* ABSFieldDefs, Absbase::TABSConstraintDefs* ABSConstraintDefs, Data::Db::TFieldDefs* FieldDefs);
extern DELPHI_PACKAGE void __fastcall GetNamesList(System::Classes::TStrings* List, const System::UnicodeString Names);
extern DELPHI_PACKAGE void __fastcall FillABSIndexDef(Absbase::TABSIndexDef* ABSIndexDef, const System::UnicodeString Name, const System::UnicodeString Fields, Data::Db::TIndexOptions Options, bool Temporary, const System::UnicodeString DescFields, const System::UnicodeString CaseInsFields, const System::UnicodeString MaxIndexedSizes, Data::Db::TFieldDefs* FieldDefs);
extern DELPHI_PACKAGE void __fastcall ConvertAdvIndexDefToABSIndexDef(TABSAdvIndexDef* AdvIndexDef, Absbase::TABSIndexDef* ABSIndexDef, Data::Db::TFieldDefs* FieldDefs);
extern DELPHI_PACKAGE void __fastcall ConvertAdvIndexDefsToIndexDefs(TABSAdvIndexDefs* AdvIndexDefs, Data::Db::TIndexDefs* IndexDefs);
extern DELPHI_PACKAGE void __fastcall ConvertIndexDefsToAdvIndexDefs(Data::Db::TIndexDefs* IndexDefs, TABSAdvIndexDefs* AdvIndexDefs);
extern DELPHI_PACKAGE void __fastcall ConvertAdvIndexDefsToABSIndexDefs(TABSAdvIndexDefs* AdvIndexDefs, Absbase::TABSIndexDefs* ABSIndexDefs, Data::Db::TFieldDefs* FieldDefs);
extern DELPHI_PACKAGE void __fastcall ConvertABSIndexDefToAdvIndexDef(Absbase::TABSIndexDef* ABSIndexDef, TABSAdvIndexDef* AdvIndexDef);
extern DELPHI_PACKAGE void __fastcall ConvertABSIndexDefsToAdvIndexDefs(Absbase::TABSIndexDefs* ABSIndexDefs, TABSAdvIndexDefs* AdvIndexDefs);
extern DELPHI_PACKAGE bool __fastcall FindFieldInFieldDefs(Data::Db::TFieldDefs* FieldDefs, System::UnicodeString FieldName);
extern DELPHI_PACKAGE Abscompression::TABSCompressionAlgorithm __fastcall ConvertCompressionAlgorithmToABSCompressionAlgorithm(TCompressionAlgorithm CompressionAlgorithm);
extern DELPHI_PACKAGE TCompressionAlgorithm __fastcall ConvertABSCompressionAlgorithmToCompressionAlgorithm(Abscompression::TABSCompressionAlgorithm CompressionAlgorithm);
extern DELPHI_PACKAGE void __fastcall DbiError(int ErrorCode, System::UnicodeString ErrorMessage = System::UnicodeString());
extern DELPHI_PACKAGE void __fastcall Check(int Status, System::UnicodeString ErrorMessage = System::UnicodeString());
}	/* namespace Absmain */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_ABSMAIN)
using namespace Absmain;
#endif
#pragma pack(pop)
#pragma option pop

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