// Borland C++ Builder
// Copyright (c) 1995, 2005 by Borland Software Corporation
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Ib_services.pas' rev: 10.00

#ifndef Ib_servicesHPP
#define Ib_servicesHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member functions
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <Sysinit.hpp>	// Pascal unit
#include <Pfibinterfaces.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Messages.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Ibase.hpp>	// Pascal unit
#include <Ib_intf.hpp>	// Pascal unit
#include <Ib_externals.hpp>	// Pascal unit
#include <Variants.hpp>	// Pascal unit

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

namespace Ib_services
{
//-- type declarations -------------------------------------------------------
typedef AnsiString IB_Services__1[13];

#pragma option push -b-
enum TProtocol { TCP, SPX, NamedPipe, Local };
#pragma option pop

#pragma option push -b-
enum TOutputBufferOption { ByLine, ByChunk };
#pragma option pop

class DELPHICLASS TpFIBCustomService;
typedef void __fastcall (__closure *TLoginEvent)(TpFIBCustomService* Database, Classes::TStrings* LoginParams);

class PASCALIMPLEMENTATION TpFIBCustomService : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	Ib_intf::_di_IIBClientLibrary FClientLibrary;
	AnsiString FLibraryName;
	Pfibinterfaces::_di_ISQLLogger FSQLLogger;
	void __fastcall LoadLibrary(void);
	void __fastcall SetSQLLogger(const Pfibinterfaces::_di_ISQLLogger Value);
	bool FParamsChanged;
	char *FSPB;
	char *FQuerySPB;
	short FSPBLength;
	short FQuerySPBLength;
	TLoginEvent FOnLogin;
	bool FLoginPrompt;
	int FBufferSize;
	char *FOutputBuffer;
	AnsiString FQueryParams;
	AnsiString FServerName;
	void * *FHandle;
	bool FStreamedActive;
	Classes::TNotifyEvent FOnAttach;
	TOutputBufferOption FOutputBufferOption;
	TProtocol FProtocol;
	Classes::TStrings* FParams;
	bool __fastcall GetActive(void);
	AnsiString __fastcall GetServiceParamBySPB(const int Idx);
	void __fastcall SetActive(const bool Value);
	void __fastcall SetBufferSize(const int Value);
	void __fastcall SetParams(const Classes::TStrings* Value);
	void __fastcall SetServerName(const AnsiString Value);
	void __fastcall SetProtocol(const TProtocol Value);
	void __fastcall SetServiceParamBySPB(const int Idx, const AnsiString Value);
	int __fastcall IndexOfSPBConst(AnsiString st);
	void __fastcall ParamsChange(System::TObject* Sender);
	void __fastcall ParamsChanging(System::TObject* Sender);
	void __fastcall CheckServerName(void);
	int __fastcall Call(int ErrCode, bool RaiseError);
	AnsiString __fastcall ParseString(int &RunLen);
	int __fastcall ParseInteger(int &RunLen);
	void __fastcall GenerateSPB(Classes::TStrings* sl, AnsiString &SPB, short &SPBLength);
	void __fastcall SetLibraryName(const AnsiString Value);
	bool __fastcall StoredLibraryName(void);
	
protected:
	virtual void __fastcall Loaded(void);
	virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation);
	bool __fastcall Login(void);
	void __fastcall CheckActive(void);
	void __fastcall CheckInactive(void);
	__property char * OutputBuffer = {read=FOutputBuffer};
	__property TOutputBufferOption OutputBufferOption = {read=FOutputBufferOption, write=FOutputBufferOption, nodefault};
	__property int BufferSize = {read=FBufferSize, write=SetBufferSize, default=32000};
	void __fastcall InternalServiceQuery(void);
	__property AnsiString ServiceQueryParams = {read=FQueryParams, write=FQueryParams};
	
public:
	__fastcall virtual TpFIBCustomService(Classes::TComponent* AOwner);
	__fastcall virtual ~TpFIBCustomService(void);
	void __fastcall Attach(void);
	void __fastcall Detach(void);
	__property Ib_externals::PVoid Handle = {read=FHandle};
	__property AnsiString ServiceParamBySPB[int Idx] = {read=GetServiceParamBySPB, write=SetServiceParamBySPB};
	
__published:
	__property bool Active = {read=GetActive, write=SetActive, default=0};
	__property AnsiString ServerName = {read=FServerName, write=SetServerName};
	__property TProtocol Protocol = {read=FProtocol, write=SetProtocol, default=3};
	__property Classes::TStrings* Params = {read=FParams, write=SetParams};
	__property bool LoginPrompt = {read=FLoginPrompt, write=FLoginPrompt, default=1};
	__property Classes::TNotifyEvent OnAttach = {read=FOnAttach, write=FOnAttach};
	__property TLoginEvent OnLogin = {read=FOnLogin, write=FOnLogin};
	__property AnsiString LibraryName = {read=FLibraryName, write=SetLibraryName, stored=StoredLibraryName};
	__property Pfibinterfaces::_di_ISQLLogger SQLLogger = {read=FSQLLogger, write=SetSQLLogger};
};


struct TDatabaseInfo
{
	
public:
	int NoOfAttachments;
	int NoOfDatabases;
	Variant DbName;
} ;

struct TLicenseInfo
{
	
public:
	Variant Key;
	Variant Id;
	Variant Desc;
	int LicensedUsers;
} ;

struct TLicenseMaskInfo
{
	
public:
	int LicenseMask;
	int CapabilityMask;
} ;

struct TConfigFileData
{
	
public:
	Variant ConfigFileValue;
	Variant ConfigFileKey;
} ;

struct TConfigParams
{
	
public:
	TConfigFileData ConfigFileData;
	AnsiString BaseLocation;
	AnsiString LockFileLocation;
	AnsiString MessageFileLocation;
	AnsiString SecurityDatabaseLocation;
} ;

struct TVersionInfo
{
	
public:
	AnsiString ServerVersion;
	AnsiString ServerImplementation;
	int ServiceVersion;
} ;

#pragma option push -b-
enum TPropertyOption { Database, License, LicenseMask, ConfigParameters, Version };
#pragma option pop

typedef Set<TPropertyOption, Database, Version>  TPropertyOptions;

class DELPHICLASS TpFIBServerProperties;
class PASCALIMPLEMENTATION TpFIBServerProperties : public TpFIBCustomService 
{
	typedef TpFIBCustomService inherited;
	
private:
	TPropertyOptions FOptions;
	TDatabaseInfo FDatabaseInfo;
	TLicenseInfo FLicenseInfo;
	TLicenseMaskInfo FLicenseMaskInfo;
	TVersionInfo FVersionInfo;
	TConfigParams FConfigParams;
	void __fastcall ParseConfigFileData(int &RunLen);
	
public:
	__fastcall virtual TpFIBServerProperties(Classes::TComponent* AOwner);
	__fastcall virtual ~TpFIBServerProperties(void);
	void __fastcall Fetch(void);
	void __fastcall FetchDatabaseInfo(void);
	void __fastcall FetchLicenseInfo(void);
	void __fastcall FetchLicenseMaskInfo(void);
	void __fastcall FetchConfigParams(void);
	void __fastcall FetchVersionInfo(void);
	__property TDatabaseInfo DatabaseInfo = {read=FDatabaseInfo};
	__property TLicenseInfo LicenseInfo = {read=FLicenseInfo};
	__property TLicenseMaskInfo LicenseMaskInfo = {read=FLicenseMaskInfo};
	__property TVersionInfo VersionInfo = {read=FVersionInfo};
	__property TConfigParams ConfigParams = {read=FConfigParams};
	
__published:
	__property TPropertyOptions Options = {read=FOptions, write=FOptions, nodefault};
};


class DELPHICLASS TpFIBControlService;
class PASCALIMPLEMENTATION TpFIBControlService : public TpFIBCustomService 
{
	typedef TpFIBCustomService inherited;
	
private:
	AnsiString FStartParams;
	char *FStartSPB;
	int FStartSPBLength;
	bool __fastcall GetIsServiceRunning(void);
	
protected:
	__property AnsiString ServiceStartParams = {read=FStartParams, write=FStartParams};
	virtual void __fastcall SetServiceStartOptions(void);
	void __fastcall ServiceStartAddParam(AnsiString Value, int param);
	void __fastcall ServiceStartAddParam1(int Value, int param);
	void __fastcall InternalServiceStart(void);
	
public:
	__fastcall virtual TpFIBControlService(Classes::TComponent* AOwner);
	virtual void __fastcall ServiceStart(void);
	__property bool IsServiceRunning = {read=GetIsServiceRunning, nodefault};
public:
	#pragma option push -w-inl
	/* TpFIBCustomService.Destroy */ inline __fastcall virtual ~TpFIBControlService(void) { }
	#pragma option pop
	
};


typedef void __fastcall (__closure *TServiceGetTextNotify)(System::TObject* Sender, const AnsiString Text);

class DELPHICLASS TpFIBControlAndQueryService;
class PASCALIMPLEMENTATION TpFIBControlAndQueryService : public TpFIBControlService 
{
	typedef TpFIBControlService inherited;
	
private:
	bool FEof;
	int FAction;
	TServiceGetTextNotify FOnTextNotify;
	void __fastcall SetAction(int Value);
	
protected:
	__property int Action = {read=FAction, write=SetAction, nodefault};
	__property TServiceGetTextNotify OnTextNotify = {read=FOnTextNotify, write=FOnTextNotify};
	
public:
	__fastcall virtual TpFIBControlAndQueryService(Classes::TComponent* AOwner);
	AnsiString __fastcall GetNextLine();
	AnsiString __fastcall GetNextChunk();
	virtual void __fastcall ServiceStart(void);
	__property bool Eof = {read=FEof, nodefault};
	
__published:
	__property BufferSize  = {default=32000};
public:
	#pragma option push -w-inl
	/* TpFIBCustomService.Destroy */ inline __fastcall virtual ~TpFIBControlAndQueryService(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TShutdownMode { Forced, DenyTransaction, DenyAttachment };
#pragma option pop

class DELPHICLASS TpFIBConfigService;
class PASCALIMPLEMENTATION TpFIBConfigService : public TpFIBControlService 
{
	typedef TpFIBControlService inherited;
	
private:
	AnsiString FDatabaseName;
	void __fastcall SetDatabaseName(const AnsiString Value);
	
public:
	virtual void __fastcall ServiceStart(void);
	void __fastcall ShutdownDatabase(TShutdownMode Options, int Wait);
	void __fastcall SetSweepInterval(int Value);
	void __fastcall SetDBSqlDialect(int Value);
	void __fastcall SetPageBuffers(int Value);
	void __fastcall ActivateShadow(void);
	void __fastcall BringDatabaseOnline(void);
	void __fastcall SetReserveSpace(bool Value);
	void __fastcall SetAsyncMode(bool Value);
	void __fastcall SetReadOnly(bool Value);
	
__published:
	__property AnsiString DatabaseName = {read=FDatabaseName, write=SetDatabaseName};
public:
	#pragma option push -w-inl
	/* TpFIBControlService.Create */ inline __fastcall virtual TpFIBConfigService(Classes::TComponent* AOwner) : TpFIBControlService(AOwner) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TpFIBCustomService.Destroy */ inline __fastcall virtual ~TpFIBConfigService(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TLicensingAction { LicenseAdd, LicenseRemove };
#pragma option pop

class DELPHICLASS TpFIBLicensingService;
class PASCALIMPLEMENTATION TpFIBLicensingService : public TpFIBControlService 
{
	typedef TpFIBControlService inherited;
	
private:
	AnsiString FID;
	AnsiString FKey;
	TLicensingAction FAction;
	void __fastcall SetAction(TLicensingAction Value);
	
protected:
	virtual void __fastcall SetServiceStartOptions(void);
	
public:
	void __fastcall AddLicense(void);
	void __fastcall RemoveLicense(void);
	
__published:
	__property TLicensingAction Action = {read=FAction, write=SetAction, default=0};
	__property AnsiString Key = {read=FKey, write=FKey};
	__property AnsiString ID = {read=FID, write=FID};
public:
	#pragma option push -w-inl
	/* TpFIBControlService.Create */ inline __fastcall virtual TpFIBLicensingService(Classes::TComponent* AOwner) : TpFIBControlService(AOwner) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TpFIBCustomService.Destroy */ inline __fastcall virtual ~TpFIBLicensingService(void) { }
	#pragma option pop
	
};


class DELPHICLASS TpFIBLogService;
class PASCALIMPLEMENTATION TpFIBLogService : public TpFIBControlAndQueryService 
{
	typedef TpFIBControlAndQueryService inherited;
	
protected:
	virtual void __fastcall SetServiceStartOptions(void);
	
__published:
	__property OnTextNotify ;
public:
	#pragma option push -w-inl
	/* TpFIBControlAndQueryService.Create */ inline __fastcall virtual TpFIBLogService(Classes::TComponent* AOwner) : TpFIBControlAndQueryService(AOwner) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TpFIBCustomService.Destroy */ inline __fastcall virtual ~TpFIBLogService(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TStatOption { DataPages, DbLog, HeaderPages, IndexPages, SystemRelations };
#pragma option pop

typedef Set<TStatOption, DataPages, SystemRelations>  TStatOptions;

class DELPHICLASS TpFIBStatisticalService;
class PASCALIMPLEMENTATION TpFIBStatisticalService : public TpFIBControlAndQueryService 
{
	typedef TpFIBControlAndQueryService inherited;
	
private:
	AnsiString FDatabaseName;
	TStatOptions FOptions;
	void __fastcall SetDatabaseName(const AnsiString Value);
	
protected:
	virtual void __fastcall SetServiceStartOptions(void);
	
__published:
	__property AnsiString DatabaseName = {read=FDatabaseName, write=SetDatabaseName};
	__property TStatOptions Options = {read=FOptions, write=FOptions, nodefault};
	__property OnTextNotify ;
public:
	#pragma option push -w-inl
	/* TpFIBControlAndQueryService.Create */ inline __fastcall virtual TpFIBStatisticalService(Classes::TComponent* AOwner) : TpFIBControlAndQueryService(AOwner) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TpFIBCustomService.Destroy */ inline __fastcall virtual ~TpFIBStatisticalService(void) { }
	#pragma option pop
	
};


class DELPHICLASS TpFIBBackupRestoreService;
class PASCALIMPLEMENTATION TpFIBBackupRestoreService : public TpFIBControlAndQueryService 
{
	typedef TpFIBControlAndQueryService inherited;
	
private:
	bool FVerbose;
	
__published:
	__property bool Verbose = {read=FVerbose, write=FVerbose, default=0};
	__property OnTextNotify ;
public:
	#pragma option push -w-inl
	/* TpFIBControlAndQueryService.Create */ inline __fastcall virtual TpFIBBackupRestoreService(Classes::TComponent* AOwner) : TpFIBControlAndQueryService(AOwner) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TpFIBCustomService.Destroy */ inline __fastcall virtual ~TpFIBBackupRestoreService(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TBackupOption { IgnoreChecksums, IgnoreLimbo, MetadataOnly, NoGarbageCollection, OldMetadataDesc, NonTransportable, ConvertExtTables };
#pragma option pop

typedef Set<TBackupOption, IgnoreChecksums, ConvertExtTables>  TBackupOptions;

class DELPHICLASS TpFIBBackupService;
class PASCALIMPLEMENTATION TpFIBBackupService : public TpFIBBackupRestoreService 
{
	typedef TpFIBBackupRestoreService inherited;
	
private:
	AnsiString FDatabaseName;
	TBackupOptions FOptions;
	Classes::TStrings* FBackupFile;
	int FBlockingFactor;
	
protected:
	virtual void __fastcall SetServiceStartOptions(void);
	void __fastcall SetBackupFile(Classes::TStrings* Value);
	
public:
	__fastcall virtual TpFIBBackupService(Classes::TComponent* AOwner);
	__fastcall virtual ~TpFIBBackupService(void);
	
__published:
	__property Classes::TStrings* BackupFile = {read=FBackupFile, write=SetBackupFile};
	__property int BlockingFactor = {read=FBlockingFactor, write=FBlockingFactor, nodefault};
	__property AnsiString DatabaseName = {read=FDatabaseName, write=FDatabaseName};
	__property TBackupOptions Options = {read=FOptions, write=FOptions, nodefault};
};


#pragma option push -b-
enum TRestoreOption { DeactivateIndexes, NoShadow, NoValidityCheck, OneRelationAtATime, Replace, CreateNewDB, UseAllSpace };
#pragma option pop

typedef Set<TRestoreOption, DeactivateIndexes, UseAllSpace>  TRestoreOptions;

class DELPHICLASS TpFIBRestoreService;
class PASCALIMPLEMENTATION TpFIBRestoreService : public TpFIBBackupRestoreService 
{
	typedef TpFIBBackupRestoreService inherited;
	
private:
	Classes::TStrings* FDatabaseName;
	Classes::TStrings* FBackupFile;
	TRestoreOptions FOptions;
	int FPageSize;
	int FPageBuffers;
	
protected:
	virtual void __fastcall SetServiceStartOptions(void);
	void __fastcall SetBackupFile(Classes::TStrings* Value);
	void __fastcall SetDatabaseName(Classes::TStrings* Value);
	
public:
	__fastcall virtual TpFIBRestoreService(Classes::TComponent* AOwner);
	__fastcall virtual ~TpFIBRestoreService(void);
	
__published:
	__property Classes::TStrings* DatabaseName = {read=FDatabaseName, write=SetDatabaseName};
	__property Classes::TStrings* BackupFile = {read=FBackupFile, write=SetBackupFile};
	__property int PageSize = {read=FPageSize, write=FPageSize, nodefault};
	__property int PageBuffers = {read=FPageBuffers, write=FPageBuffers, nodefault};
	__property TRestoreOptions Options = {read=FOptions, write=FOptions, default=32};
};


#pragma option push -b-
enum TValidateOption { LimboTransactions, CheckDB, IgnoreChecksum, KillShadows, MendDB, SweepDB, ValidateDB, ValidateFull };
#pragma option pop

typedef Set<TValidateOption, LimboTransactions, ValidateFull>  TValidateOptions;

#pragma option push -b-
enum TTransactionGlobalAction { CommitGlobal, RollbackGlobal, RecoverTwoPhaseGlobal, NoGlobalAction };
#pragma option pop

#pragma option push -b-
enum TTransactionState { LimboState, CommitState, RollbackState, UnknownState };
#pragma option pop

#pragma option push -b-
enum TTransactionAdvise { CommitAdvise, RollbackAdvise, UnknownAdvise };
#pragma option pop

#pragma option push -b-
enum TServiceTransactionAction { CommitAction, RollbackAction };
#pragma option pop

class DELPHICLASS TLimboTransactionInfo;
class PASCALIMPLEMENTATION TLimboTransactionInfo : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	bool MultiDatabase;
	int ID;
	AnsiString HostSite;
	AnsiString RemoteSite;
	AnsiString RemoteDatabasePath;
	TTransactionState State;
	TTransactionAdvise Advise;
	TServiceTransactionAction Action;
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TLimboTransactionInfo(void) : System::TObject() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TLimboTransactionInfo(void) { }
	#pragma option pop
	
};


class DELPHICLASS TpFIBValidationService;
class PASCALIMPLEMENTATION TpFIBValidationService : public TpFIBControlAndQueryService 
{
	typedef TpFIBControlAndQueryService inherited;
	
private:
	AnsiString FDatabaseName;
	TValidateOptions FOptions;
	Classes::TList* FLimboTransactionInfo;
	TTransactionGlobalAction FGlobalAction;
	void __fastcall SetDatabaseName(const AnsiString Value);
	TLimboTransactionInfo* __fastcall GetLimboTransactionInfo(int index);
	int __fastcall GetLimboTransactionInfoCount(void);
	
protected:
	virtual void __fastcall SetServiceStartOptions(void);
	
public:
	__fastcall virtual TpFIBValidationService(Classes::TComponent* AOwner);
	__fastcall virtual ~TpFIBValidationService(void);
	void __fastcall FetchLimboTransactionInfo(void);
	void __fastcall FixLimboTransactionErrors(void);
	__property TLimboTransactionInfo* LimboTransactionInfo[int Index] = {read=GetLimboTransactionInfo};
	__property int LimboTransactionInfoCount = {read=GetLimboTransactionInfoCount, nodefault};
	
__published:
	__property AnsiString DatabaseName = {read=FDatabaseName, write=SetDatabaseName};
	__property TValidateOptions Options = {read=FOptions, write=FOptions, nodefault};
	__property TTransactionGlobalAction GlobalAction = {read=FGlobalAction, write=FGlobalAction, nodefault};
	__property OnTextNotify ;
};


class DELPHICLASS TUserInfo;
class PASCALIMPLEMENTATION TUserInfo : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	AnsiString UserName;
	AnsiString FirstName;
	AnsiString MiddleName;
	AnsiString LastName;
	int GroupID;
	int UserID;
public:
	#pragma option push -w-inl
	/* TObject.Create */ inline __fastcall TUserInfo(void) : System::TObject() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TUserInfo(void) { }
	#pragma option pop
	
};


typedef TUserInfo* *PUserInfo;

#pragma option push -b-
enum TSecurityAction { ActionAddUser, ActionDeleteUser, ActionModifyUser, ActionDisplayUser };
#pragma option pop

#pragma option push -b-
enum TSecurityModifyParam { ModifyFirstName, ModifyMiddleName, ModifyLastName, ModifyUserId, ModifyGroupId, ModifyPassword };
#pragma option pop

typedef Set<TSecurityModifyParam, ModifyFirstName, ModifyPassword>  TSecurityModifyParams;

class DELPHICLASS TpFIBSecurityService;
class PASCALIMPLEMENTATION TpFIBSecurityService : public TpFIBControlAndQueryService 
{
	typedef TpFIBControlAndQueryService inherited;
	
private:
	int FUserID;
	int FGroupID;
	AnsiString FFirstName;
	AnsiString FUserName;
	AnsiString FPassword;
	AnsiString FSQLRole;
	AnsiString FLastName;
	AnsiString FMiddleName;
	Classes::TList* FUserInfo;
	TSecurityAction FSecurityAction;
	TSecurityModifyParams FModifyParams;
	void __fastcall SetSecurityAction(TSecurityAction Value);
	void __fastcall SetFirstName(const AnsiString Value);
	void __fastcall SetMiddleName(const AnsiString Value);
	void __fastcall SetLastName(const AnsiString Value);
	void __fastcall SetPassword(const AnsiString Value);
	void __fastcall SetUserId(int Value);
	void __fastcall SetGroupId(int Value);
	void __fastcall FetchUserInfo(void);
	TUserInfo* __fastcall GetUserInfo(int Index);
	int __fastcall GetUserInfoCount(void);
	
protected:
	virtual void __fastcall Loaded(void);
	virtual void __fastcall SetServiceStartOptions(void);
	
public:
	__fastcall virtual TpFIBSecurityService(Classes::TComponent* AOwner);
	__fastcall virtual ~TpFIBSecurityService(void);
	void __fastcall DisplayUsers(void);
	void __fastcall DisplayUser(AnsiString UserName);
	void __fastcall AddUser(void);
	void __fastcall DeleteUser(void);
	void __fastcall ModifyUser(void);
	void __fastcall ClearParams(void);
	__property TUserInfo* UserInfo[int Index] = {read=GetUserInfo};
	__property int UserInfoCount = {read=GetUserInfoCount, nodefault};
	
__published:
	__property TSecurityAction SecurityAction = {read=FSecurityAction, write=SetSecurityAction, nodefault};
	__property AnsiString SQlRole = {read=FSQLRole, write=FSQLRole};
	__property AnsiString UserName = {read=FUserName, write=FUserName};
	__property AnsiString FirstName = {read=FFirstName, write=SetFirstName};
	__property AnsiString MiddleName = {read=FMiddleName, write=SetMiddleName};
	__property AnsiString LastName = {read=FLastName, write=SetLastName};
	__property int UserID = {read=FUserID, write=SetUserId, nodefault};
	__property int GroupID = {read=FGroupID, write=SetGroupId, nodefault};
	__property AnsiString Password = {read=FPassword, write=SetPassword};
};


//-- var, const, procedure ---------------------------------------------------
static const Word DefaultBufferSize = 0x7d00;
#define SPBPrefix "isc_spb_"
extern PACKAGE AnsiString SPBConstantNames[13];
extern PACKAGE int SPBConstantValues[13];

}	/* namespace Ib_services */
using namespace Ib_services;
#pragma pack(pop)
#pragma option pop

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