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

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

#ifndef IndictcommonHPP
#define IndictcommonHPP

#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 <Classes.hpp>	// Pascal unit

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

namespace Indictcommon
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TIdMatch;
class PASCALIMPLEMENTATION TIdMatch : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
protected:
	AnsiString FDB;
	AnsiString FWord;
	
__published:
	__property AnsiString DB = {read=FDB, write=FDB};
	__property AnsiString Word = {read=FWord, write=FWord};
public:
	#pragma option push -w-inl
	/* TCollectionItem.Create */ inline __fastcall virtual TIdMatch(Classes::TCollection* Collection) : Classes::TCollectionItem(Collection) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TIdMatch(void) { }
	#pragma option pop
	
};


class DELPHICLASS TIdMatchList;
class PASCALIMPLEMENTATION TIdMatchList : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TIdMatch* operator[](int AIndex) { return Items[AIndex]; }
	
protected:
	TIdMatch* __fastcall GetItems(int AIndex);
	void __fastcall SetItems(int AIndex, const TIdMatch* AValue);
	
public:
	__fastcall virtual TIdMatchList(void);
	int __fastcall IndexOf(TIdMatch* AItem);
	HIDESBASE TIdMatch* __fastcall Add(void);
	__property TIdMatch* Items[int AIndex] = {read=GetItems, write=SetItems/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TIdMatchList(void) { }
	#pragma option pop
	
};


class DELPHICLASS TIdGeneric;
class PASCALIMPLEMENTATION TIdGeneric : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
protected:
	AnsiString FName;
	AnsiString FDesc;
	
__published:
	__property AnsiString Name = {read=FName, write=FName};
	__property AnsiString Desc = {read=FDesc, write=FDesc};
public:
	#pragma option push -w-inl
	/* TCollectionItem.Create */ inline __fastcall virtual TIdGeneric(Classes::TCollection* Collection) : Classes::TCollectionItem(Collection) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TIdGeneric(void) { }
	#pragma option pop
	
};


class DELPHICLASS TIdStrategy;
class PASCALIMPLEMENTATION TIdStrategy : public TIdGeneric 
{
	typedef TIdGeneric inherited;
	
public:
	#pragma option push -w-inl
	/* TCollectionItem.Create */ inline __fastcall virtual TIdStrategy(Classes::TCollection* Collection) : TIdGeneric(Collection) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TIdStrategy(void) { }
	#pragma option pop
	
};


class DELPHICLASS TIdStrategyList;
class PASCALIMPLEMENTATION TIdStrategyList : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TIdStrategy* operator[](int AIndex) { return Items[AIndex]; }
	
protected:
	TIdStrategy* __fastcall GetItems(int AIndex);
	void __fastcall SetItems(int AIndex, const TIdStrategy* AValue);
	
public:
	__fastcall virtual TIdStrategyList(void);
	int __fastcall IndexOf(TIdStrategy* AItem);
	HIDESBASE TIdStrategy* __fastcall Add(void);
	__property TIdStrategy* Items[int AIndex] = {read=GetItems, write=SetItems/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TIdStrategyList(void) { }
	#pragma option pop
	
};


class DELPHICLASS TIdDBInfo;
class PASCALIMPLEMENTATION TIdDBInfo : public TIdGeneric 
{
	typedef TIdGeneric inherited;
	
public:
	#pragma option push -w-inl
	/* TCollectionItem.Create */ inline __fastcall virtual TIdDBInfo(Classes::TCollection* Collection) : TIdGeneric(Collection) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TCollectionItem.Destroy */ inline __fastcall virtual ~TIdDBInfo(void) { }
	#pragma option pop
	
};


class DELPHICLASS TIdDBList;
class PASCALIMPLEMENTATION TIdDBList : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TIdDBInfo* operator[](int AIndex) { return Items[AIndex]; }
	
protected:
	TIdDBInfo* __fastcall GetItems(int AIndex);
	void __fastcall SetItems(int AIndex, const TIdDBInfo* AValue);
	
public:
	__fastcall virtual TIdDBList(void);
	int __fastcall IndexOf(TIdDBInfo* AItem);
	HIDESBASE TIdDBInfo* __fastcall Add(void);
	__property TIdDBInfo* Items[int AIndex] = {read=GetItems, write=SetItems/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TIdDBList(void) { }
	#pragma option pop
	
};


class DELPHICLASS TIdDefinition;
class PASCALIMPLEMENTATION TIdDefinition : public Classes::TCollectionItem 
{
	typedef Classes::TCollectionItem inherited;
	
protected:
	AnsiString FWord;
	Classes::TStrings* FDefinition;
	TIdDBInfo* FDB;
	void __fastcall SetDefinition(Classes::TStrings* AValue);
	
__published:
	__fastcall virtual TIdDefinition(Classes::TCollection* AOwner);
	__fastcall virtual ~TIdDefinition(void);
	__property AnsiString Word = {read=FWord, write=FWord};
	__property TIdDBInfo* DB = {read=FDB, write=FDB};
	__property Classes::TStrings* Definition = {read=FDefinition, write=SetDefinition};
};


class DELPHICLASS TIdDefinitions;
class PASCALIMPLEMENTATION TIdDefinitions : public Classes::TCollection 
{
	typedef Classes::TCollection inherited;
	
public:
	TIdDefinition* operator[](int AIndex) { return Items[AIndex]; }
	
protected:
	TIdDefinition* __fastcall GetItems(int AIndex);
	void __fastcall SetItems(int AIndex, const TIdDefinition* AValue);
	
public:
	__fastcall virtual TIdDefinitions(void);
	int __fastcall IndexOf(TIdDefinition* AItem);
	HIDESBASE TIdDefinition* __fastcall Add(void);
	__property TIdDefinition* Items[int AIndex] = {read=GetItems, write=SetItems/*, default*/};
public:
	#pragma option push -w-inl
	/* TCollection.Destroy */ inline __fastcall virtual ~TIdDefinitions(void) { }
	#pragma option pop
	
};


//-- var, const, procedure ---------------------------------------------------

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

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