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

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

#ifndef InhttpheaderinfoHPP
#define InhttpheaderinfoHPP

#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
#include <Inauthentication.hpp>	// Pascal unit
#include <Inglobal.hpp>	// Pascal unit
#include <Inglobalprotocols.hpp>	// Pascal unit
#include <Inheaderlist.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit

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

namespace Inhttpheaderinfo
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TIdEntityHeaderInfo;
class PASCALIMPLEMENTATION TIdEntityHeaderInfo : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
protected:
	AnsiString FCacheControl;
	Inheaderlist::TInHeaderList* FRawHeaders;
	AnsiString FConnection;
	AnsiString FContentEncoding;
	AnsiString FContentLanguage;
	int FContentLength;
	unsigned FContentRangeEnd;
	unsigned FContentRangeStart;
	AnsiString FContentType;
	AnsiString FContentVersion;
	Inheaderlist::TInHeaderList* FCustomHeaders;
	System::TDateTime FDate;
	System::TDateTime FExpires;
	System::TDateTime FLastModified;
	AnsiString FPragma;
	bool FHasContentLength;
	virtual void __fastcall AssignTo(Classes::TPersistent* Destination);
	virtual void __fastcall ProcessHeaders(void);
	virtual void __fastcall SetHeaders(void);
	void __fastcall SetContentLength(const int AValue);
	void __fastcall SetCustomHeaders(const Inheaderlist::TInHeaderList* AValue);
	
public:
	virtual void __fastcall Clear(void);
	__fastcall virtual TIdEntityHeaderInfo(void);
	__fastcall virtual ~TIdEntityHeaderInfo(void);
	__property bool HasContentLength = {read=FHasContentLength, nodefault};
	__property Inheaderlist::TInHeaderList* RawHeaders = {read=FRawHeaders};
	
__published:
	__property AnsiString CacheControl = {read=FCacheControl, write=FCacheControl};
	__property AnsiString Connection = {read=FConnection, write=FConnection};
	__property AnsiString ContentEncoding = {read=FContentEncoding, write=FContentEncoding};
	__property AnsiString ContentLanguage = {read=FContentLanguage, write=FContentLanguage};
	__property int ContentLength = {read=FContentLength, write=SetContentLength, nodefault};
	__property unsigned ContentRangeEnd = {read=FContentRangeEnd, write=FContentRangeEnd, nodefault};
	__property unsigned ContentRangeStart = {read=FContentRangeStart, write=FContentRangeStart, nodefault};
	__property AnsiString ContentType = {read=FContentType, write=FContentType};
	__property AnsiString ContentVersion = {read=FContentVersion, write=FContentVersion};
	__property Inheaderlist::TInHeaderList* CustomHeaders = {read=FCustomHeaders, write=SetCustomHeaders};
	__property System::TDateTime Date = {read=FDate, write=FDate};
	__property System::TDateTime Expires = {read=FExpires, write=FExpires};
	__property System::TDateTime LastModified = {read=FLastModified, write=FLastModified};
	__property AnsiString Pragma = {read=FPragma, write=FPragma};
};


class DELPHICLASS TIdProxyConnectionInfo;
class PASCALIMPLEMENTATION TIdProxyConnectionInfo : public Classes::TPersistent 
{
	typedef Classes::TPersistent inherited;
	
protected:
	Inauthentication::TInAuthentication* FAuthentication;
	AnsiString FPassword;
	int FPort;
	AnsiString FServer;
	AnsiString FUsername;
	bool FBasicByDefault;
	virtual void __fastcall AssignTo(Classes::TPersistent* Destination);
	void __fastcall SetProxyPort(const int Value);
	void __fastcall SetProxyServer(const AnsiString Value);
	
public:
	__fastcall TIdProxyConnectionInfo(void);
	void __fastcall Clear(void);
	__fastcall virtual ~TIdProxyConnectionInfo(void);
	void __fastcall SetHeaders(Inheaderlist::TInHeaderList* Headers);
	__property Inauthentication::TInAuthentication* Authentication = {read=FAuthentication, write=FAuthentication};
	
__published:
	__property bool BasicAuthentication = {read=FBasicByDefault, write=FBasicByDefault, nodefault};
	__property AnsiString ProxyPassword = {read=FPassword, write=FPassword};
	__property int ProxyPort = {read=FPort, write=SetProxyPort, nodefault};
	__property AnsiString ProxyServer = {read=FServer, write=SetProxyServer};
	__property AnsiString ProxyUsername = {read=FUsername, write=FUsername};
};


class DELPHICLASS TIdRequestHeaderInfo;
class PASCALIMPLEMENTATION TIdRequestHeaderInfo : public TIdEntityHeaderInfo 
{
	typedef TIdEntityHeaderInfo inherited;
	
protected:
	AnsiString FAccept;
	AnsiString FAcceptCharSet;
	AnsiString FAcceptEncoding;
	AnsiString FAcceptLanguage;
	AnsiString FExpect;
	AnsiString FFrom;
	AnsiString FPassword;
	AnsiString FReferer;
	AnsiString FUserAgent;
	AnsiString FUserName;
	AnsiString FHost;
	bool FBasicByDefault;
	AnsiString FProxyConnection;
	Inauthentication::TInAuthentication* FAuthentication;
	virtual void __fastcall AssignTo(Classes::TPersistent* Destination);
	virtual void __fastcall ProcessHeaders(void);
	virtual void __fastcall SetHeaders(void);
	
public:
	virtual void __fastcall Clear(void);
	__property Inauthentication::TInAuthentication* Authentication = {read=FAuthentication, write=FAuthentication};
	__fastcall virtual ~TIdRequestHeaderInfo(void);
	
__published:
	__property AnsiString Accept = {read=FAccept, write=FAccept};
	__property AnsiString AcceptCharSet = {read=FAcceptCharSet, write=FAcceptCharSet};
	__property AnsiString AcceptEncoding = {read=FAcceptEncoding, write=FAcceptEncoding};
	__property AnsiString AcceptLanguage = {read=FAcceptLanguage, write=FAcceptLanguage};
	__property bool BasicAuthentication = {read=FBasicByDefault, write=FBasicByDefault, nodefault};
	__property AnsiString Host = {read=FHost, write=FHost};
	__property AnsiString From = {read=FFrom, write=FFrom};
	__property AnsiString Password = {read=FPassword, write=FPassword};
	__property AnsiString Referer = {read=FReferer, write=FReferer};
	__property AnsiString UserAgent = {read=FUserAgent, write=FUserAgent};
	__property AnsiString Username = {read=FUserName, write=FUserName};
	__property AnsiString ProxyConnection = {read=FProxyConnection, write=FProxyConnection};
public:
	#pragma option push -w-inl
	/* TIdEntityHeaderInfo.Create */ inline __fastcall virtual TIdRequestHeaderInfo(void) : TIdEntityHeaderInfo() { }
	#pragma option pop
	
};


class DELPHICLASS TIdResponseHeaderInfo;
class PASCALIMPLEMENTATION TIdResponseHeaderInfo : public TIdEntityHeaderInfo 
{
	typedef TIdEntityHeaderInfo inherited;
	
protected:
	AnsiString FLocation;
	AnsiString FServer;
	AnsiString FProxyConnection;
	Inheaderlist::TInHeaderList* FProxyAuthenticate;
	Inheaderlist::TInHeaderList* FWWWAuthenticate;
	void __fastcall SetProxyAuthenticate(const Inheaderlist::TInHeaderList* Value);
	void __fastcall SetWWWAuthenticate(const Inheaderlist::TInHeaderList* Value);
	virtual void __fastcall ProcessHeaders(void);
	
public:
	virtual void __fastcall Clear(void);
	__fastcall virtual TIdResponseHeaderInfo(void);
	__fastcall virtual ~TIdResponseHeaderInfo(void);
	
__published:
	__property AnsiString Location = {read=FLocation, write=FLocation};
	__property AnsiString ProxyConnection = {read=FProxyConnection, write=FProxyConnection};
	__property Inheaderlist::TInHeaderList* ProxyAuthenticate = {read=FProxyAuthenticate, write=SetProxyAuthenticate};
	__property AnsiString Server = {read=FServer, write=FServer};
	__property Inheaderlist::TInHeaderList* WWWAuthenticate = {read=FWWWAuthenticate, write=SetWWWAuthenticate};
};


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

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

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