unit IMP_Classes;
interface
uses
  Windows,
  Messages,
  SysUtils,
  Variants,
  TypInfo,
  ActiveX,
  Classes,
  BASE_SYS,
  BASE_EXTERN,
  PaxScripter;
procedure RegisterIMP_Classes;
implementation
procedure TListEnumerator_GetCurrent(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsPointer := TListEnumerator(Self).GetCurrent();
end;
procedure TListEnumerator_MoveNext(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsBoolean := TListEnumerator(Self).MoveNext();
end;
function TListEnumerator__GetCurrent(Self:TListEnumerator):Pointer;
begin
  result := Self.Current;
end;
procedure TList_Add(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsInteger := TList(Self).Add(Params[0].AsPointer);
end;
procedure TList_Clear(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TList(Self).Clear();
end;
procedure TList_Delete(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TList(Self).Delete(Params[0].AsInteger);
end;
procedure TList_Error1(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TList(Self).Error(Params[0].AsString,Params[1].AsInteger);
end;
procedure TList_Exchange(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TList(Self).Exchange(Params[0].AsInteger,Params[1].AsInteger);
end;
procedure TList_Extract(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsPointer := TList(Self).Extract(Params[0].AsPointer);
end;
procedure TList_First(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsPointer := TList(Self).First();
end;
procedure TList_IndexOf(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsInteger := TList(Self).IndexOf(Params[0].AsPointer);
end;
procedure TList_Insert(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TList(Self).Insert(Params[0].AsInteger,Params[1].AsPointer);
end;
procedure TList_Last(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsPointer := TList(Self).Last();
end;
procedure TList_Move(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TList(Self).Move(Params[0].AsInteger,Params[1].AsInteger);
end;
procedure TList_Remove(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsInteger := TList(Self).Remove(Params[0].AsPointer);
end;
procedure TList_Pack(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TList(Self).Pack();
end;
function TList__GetCapacity(Self:TList):Integer;
begin
  result := Self.Capacity;
end;
procedure TList__PutCapacity(Self:TList;const Value: Integer);
begin
  Self.Capacity := Value;
end;
function TList__GetCount(Self:TList):Integer;
begin
  result := Self.Count;
end;
procedure TList__PutCount(Self:TList;const Value: Integer);
begin
  Self.Count := Value;
end;
function TList__GetItems(Self:TList;Index: Integer):Pointer;
begin
  result := Self.Items[Index];
end;
procedure TList__PutItems(Self:TList;Index: Integer;const Value: Pointer);
begin
  Self.Items[Index] := Value;
end;
function TList__GetList(Self:TList):PPointerList;
begin
  result := Self.List;
end;
procedure TThreadList_Add(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TThreadList(Self).Add(Params[0].AsPointer);
end;
procedure TThreadList_Clear(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TThreadList(Self).Clear();
end;
procedure TThreadList_Remove(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TThreadList(Self).Remove(Params[0].AsPointer);
end;
procedure TThreadList_UnlockList(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TThreadList(Self).UnlockList();
end;
function TThreadList__GetDuplicates(Self:TThreadList):TDuplicates;
begin
  result := Self.Duplicates;
end;
procedure TThreadList__PutDuplicates(Self:TThreadList;const Value: TDuplicates);
begin
  Self.Duplicates := Value;
end;
procedure TInterfaceListEnumerator_MoveNext(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsBoolean := TInterfaceListEnumerator(Self).MoveNext();
end;
function TInterfaceListEnumerator__GetCurrent(Self:TInterfaceListEnumerator):IInterface;
begin
  result := Self.Current;
end;
procedure TInterfaceList_Clear(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TInterfaceList(Self).Clear();
end;
procedure TInterfaceList_Delete(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TInterfaceList(Self).Delete(Params[0].AsInteger);
end;
procedure TInterfaceList_Exchange(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TInterfaceList(Self).Exchange(Params[0].AsInteger,Params[1].AsInteger);
end;
procedure TInterfaceList_Lock(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TInterfaceList(Self).Lock();
end;
procedure TInterfaceList_Unlock(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TInterfaceList(Self).Unlock();
end;
function TInterfaceList__GetCapacity(Self:TInterfaceList):Integer;
begin
  result := Self.Capacity;
end;
procedure TInterfaceList__PutCapacity(Self:TInterfaceList;const Value: Integer);
begin
  Self.Capacity := Value;
end;
function TInterfaceList__GetCount(Self:TInterfaceList):Integer;
begin
  result := Self.Count;
end;
procedure TInterfaceList__PutCount(Self:TInterfaceList;const Value: Integer);
begin
  Self.Count := Value;
end;
function TInterfaceList__GetItems(Self:TInterfaceList;Index: Integer):IInterface;
begin
  result := Self.Items[Index];
end;
procedure TInterfaceList__PutItems(Self:TInterfaceList;Index: Integer;const Value: IInterface);
begin
  Self.Items[Index] := Value;
end;
procedure TBits_OpenBit(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsInteger := TBits(Self).OpenBit();
end;
function TBits__GetBits(Self:TBits;Index: Integer):Boolean;
begin
  result := Self.Bits[Index];
end;
procedure TBits__PutBits(Self:TBits;Index: Integer;const Value: Boolean);
begin
  Self.Bits[Index] := Value;
end;
function TBits__GetSize(Self:TBits):Integer;
begin
  result := Self.Size;
end;
procedure TBits__PutSize(Self:TBits;const Value: Integer);
begin
  Self.Size := Value;
end;
procedure TPersistent_GetNamePath(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsString := TPersistent(Self).GetNamePath();
end;
procedure TInterfacedPersistent_AfterConstruction(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TInterfacedPersistent(Self).AfterConstruction();
end;
procedure TRecall_Store(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TRecall(Self).Store();
end;
procedure TRecall_Forget(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TRecall(Self).Forget();
end;
function TRecall__GetReference(Self:TRecall):TPersistent;
begin
  result := Self.Reference;
end;
procedure TCollectionItem_GetNamePath(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsString := TCollectionItem(Self).GetNamePath();
end;
function TCollectionItem__GetCollection(Self:TCollectionItem):TCollection;
begin
  result := Self.Collection;
end;
procedure TCollectionItem__PutCollection(Self:TCollectionItem;const Value: TCollection);
begin
  Self.Collection := Value;
end;
function TCollectionItem__GetID(Self:TCollectionItem):Integer;
begin
  result := Self.ID;
end;
function TCollectionItem__GetIndex(Self:TCollectionItem):Integer;
begin
  result := Self.Index;
end;
procedure TCollectionItem__PutIndex(Self:TCollectionItem;const Value: Integer);
begin
  Self.Index := Value;
end;
function TCollectionItem__GetDisplayName(Self:TCollectionItem):string;
begin
  result := Self.DisplayName;
end;
procedure TCollectionItem__PutDisplayName(Self:TCollectionItem;const Value: string);
begin
  Self.DisplayName := Value;
end;
procedure TCollectionEnumerator_MoveNext(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsBoolean := TCollectionEnumerator(Self).MoveNext();
end;
function TCollectionEnumerator__GetCurrent(Self:TCollectionEnumerator):TCollectionItem;
begin
  result := Self.Current;
end;
procedure TCollection_BeginUpdate(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TCollection(Self).BeginUpdate();
end;
procedure TCollection_Clear(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TCollection(Self).Clear();
end;
procedure TCollection_Delete(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TCollection(Self).Delete(Params[0].AsInteger);
end;
procedure TCollection_EndUpdate(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TCollection(Self).EndUpdate();
end;
procedure TCollection_GetNamePath(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsString := TCollection(Self).GetNamePath();
end;
function TCollection__GetCapacity(Self:TCollection):Integer;
begin
  result := Self.Capacity;
end;
procedure TCollection__PutCapacity(Self:TCollection;const Value: Integer);
begin
  Self.Capacity := Value;
end;
function TCollection__GetCount(Self:TCollection):Integer;
begin
  result := Self.Count;
end;
function TCollection__GetItemClass(Self:TCollection):TCollectionItemClass;
begin
  result := Self.ItemClass;
end;
function TCollection__GetItems(Self:TCollection;Index: Integer):TCollectionItem;
begin
  result := Self.Items[Index];
end;
procedure TCollection__PutItems(Self:TCollection;Index: Integer;const Value: TCollectionItem);
begin
  Self.Items[Index] := Value;
end;
procedure TStringsEnumerator_GetCurrent(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsString := TStringsEnumerator(Self).GetCurrent();
end;
procedure TStringsEnumerator_MoveNext(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsBoolean := TStringsEnumerator(Self).MoveNext();
end;
function TStringsEnumerator__GetCurrent(Self:TStringsEnumerator):string;
begin
  result := Self.Current;
end;
procedure TStrings_Add(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsInteger := TStrings(Self).Add(Params[0].AsString);
end;
procedure TStrings_Append(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStrings(Self).Append(Params[0].AsString);
end;
procedure TStrings_BeginUpdate(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStrings(Self).BeginUpdate();
end;
procedure TStrings_EndUpdate(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStrings(Self).EndUpdate();
end;
procedure TStrings_Exchange(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStrings(Self).Exchange(Params[0].AsInteger,Params[1].AsInteger);
end;
procedure TStrings_IndexOf(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsInteger := TStrings(Self).IndexOf(Params[0].AsString);
end;
procedure TStrings_IndexOfName(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsInteger := TStrings(Self).IndexOfName(Params[0].AsString);
end;
procedure TStrings_LoadFromFile(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStrings(Self).LoadFromFile(Params[0].AsString);
end;
procedure TStrings_Move(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStrings(Self).Move(Params[0].AsInteger,Params[1].AsInteger);
end;
procedure TStrings_SaveToFile(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStrings(Self).SaveToFile(Params[0].AsString);
end;
function TStrings__GetCapacity(Self:TStrings):Integer;
begin
  result := Self.Capacity;
end;
procedure TStrings__PutCapacity(Self:TStrings;const Value: Integer);
begin
  Self.Capacity := Value;
end;
function TStrings__GetCommaText(Self:TStrings):string;
begin
  result := Self.CommaText;
end;
procedure TStrings__PutCommaText(Self:TStrings;const Value: string);
begin
  Self.CommaText := Value;
end;
function TStrings__GetCount(Self:TStrings):Integer;
begin
  result := Self.Count;
end;
function TStrings__GetDelimiter(Self:TStrings):Char;
begin
  result := Self.Delimiter;
end;
procedure TStrings__PutDelimiter(Self:TStrings;const Value: Char);
begin
  Self.Delimiter := Value;
end;
function TStrings__GetDelimitedText(Self:TStrings):string;
begin
  result := Self.DelimitedText;
end;
procedure TStrings__PutDelimitedText(Self:TStrings;const Value: string);
begin
  Self.DelimitedText := Value;
end;
function TStrings__GetLineBreak(Self:TStrings):string;
begin
  result := Self.LineBreak;
end;
procedure TStrings__PutLineBreak(Self:TStrings;const Value: string);
begin
  Self.LineBreak := Value;
end;
function TStrings__GetNames(Self:TStrings;Index: Integer):string;
begin
  result := Self.Names[Index];
end;
function TStrings__GetObjects(Self:TStrings;Index: Integer):TObject;
begin
  result := Self.Objects[Index];
end;
procedure TStrings__PutObjects(Self:TStrings;Index: Integer;const Value: TObject);
begin
  Self.Objects[Index] := Value;
end;
function TStrings__GetQuoteChar(Self:TStrings):Char;
begin
  result := Self.QuoteChar;
end;
procedure TStrings__PutQuoteChar(Self:TStrings;const Value: Char);
begin
  Self.QuoteChar := Value;
end;
function TStrings__GetValues(Self:TStrings;const Name: string):string;
begin
  result := Self.Values[Name];
end;
procedure TStrings__PutValues(Self:TStrings;const Name: string;const Value: string);
begin
  Self.Values[Name] := Value;
end;
function TStrings__GetValueFromIndex(Self:TStrings;Index: Integer):string;
begin
  result := Self.ValueFromIndex[Index];
end;
procedure TStrings__PutValueFromIndex(Self:TStrings;Index: Integer;const Value: string);
begin
  Self.ValueFromIndex[Index] := Value;
end;
function TStrings__GetNameValueSeparator(Self:TStrings):Char;
begin
  result := Self.NameValueSeparator;
end;
procedure TStrings__PutNameValueSeparator(Self:TStrings;const Value: Char);
begin
  Self.NameValueSeparator := Value;
end;
function TStrings__GetStrictDelimiter(Self:TStrings):Boolean;
begin
  result := Self.StrictDelimiter;
end;
procedure TStrings__PutStrictDelimiter(Self:TStrings;const Value: Boolean);
begin
  Self.StrictDelimiter := Value;
end;
function TStrings__GetStrings(Self:TStrings;Index: Integer):string;
begin
  result := Self.Strings[Index];
end;
procedure TStrings__PutStrings(Self:TStrings;Index: Integer;const Value: string);
begin
  Self.Strings[Index] := Value;
end;
function TStrings__GetText(Self:TStrings):string;
begin
  result := Self.Text;
end;
procedure TStrings__PutText(Self:TStrings;const Value: string);
begin
  Self.Text := Value;
end;
function TStrings__GetStringsAdapter(Self:TStrings):IStringsAdapter;
begin
  result := Self.StringsAdapter;
end;
procedure TStrings__PutStringsAdapter(Self:TStrings;const Value: IStringsAdapter);
begin
  Self.StringsAdapter := Value;
end;
procedure TStringList_Add(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsInteger := TStringList(Self).Add(Params[0].AsString);
end;
procedure TStringList_Clear(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStringList(Self).Clear();
end;
procedure TStringList_Delete(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStringList(Self).Delete(Params[0].AsInteger);
end;
procedure TStringList_Exchange(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStringList(Self).Exchange(Params[0].AsInteger,Params[1].AsInteger);
end;
procedure TStringList_IndexOf(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.AsInteger := TStringList(Self).IndexOf(Params[0].AsString);
end;
procedure TStringList_Insert(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStringList(Self).Insert(Params[0].AsInteger,Params[1].AsString);
end;
procedure TStringList_Sort(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStringList(Self).Sort();
end;
function TStringList__GetDuplicates(Self:TStringList):TDuplicates;
begin
  result := Self.Duplicates;
end;
procedure TStringList__PutDuplicates(Self:TStringList;const Value: TDuplicates);
begin
  Self.Duplicates := Value;
end;
function TStringList__GetSorted(Self:TStringList):Boolean;
begin
  result := Self.Sorted;
end;
procedure TStringList__PutSorted(Self:TStringList;const Value: Boolean);
begin
  Self.Sorted := Value;
end;
function TStringList__GetCaseSensitive(Self:TStringList):Boolean;
begin
  result := Self.CaseSensitive;
end;
procedure TStringList__PutCaseSensitive(Self:TStringList;const Value: Boolean);
begin
  Self.CaseSensitive := Value;
end;
procedure TStream_Seek3(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
   result.PValue^ := TStream(Self).Seek(Params[0].PValue^,Params[1].PValue^);
end;
procedure TStream_FixupResourceHeader(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStream(Self).FixupResourceHeader(Params[0].AsInteger);
end;
procedure TStream_ReadResHeader(MethodBody: TPAXMethodBody);
begin
  with MethodBody do
TStream(Self).ReadResHeader();
end;
function TStream__GetPosition(Self:TStream):Int64;
begin
  result := Self.Position;
end;
procedure TStream__PutPosition(Self:TStream;const Value: Int64);
begin
  Self.Position := Value;
end;
function TStream__GetSize(Self:TStream):Int64;
begin
  result := Self.Size;
end;
procedure TStream__PutSize(Self:TStream;const Value: Int64);
begin
  Self.Size := Value;
end;
function THandleStream__GetHandle(Self:THandleStream):Integer;
begin
  result := Self.Handle;
end;
procedure RegisterIMP_Classes;
var H: Integer;
begin
  H := -1;//RegisterNamespace('Classes', -1);
  RegisterConstant('soFromBeginning', 0, H);
  RegisterConstant('soFromCurrent', 1, H);
  RegisterConstant('soFromEnd', 2, H);
  RegisterRTTIType(TypeInfo(TSeekOrigin));
  RegisterConstant('fmCreate', $FFFF, H);
  RegisterConstant('scShift', $2000, H);
  RegisterConstant('scCtrl', $4000, H);
  RegisterConstant('scAlt', $8000, H);
  RegisterConstant('scNone', 0, H);
  RegisterRTTIType(TypeInfo(TAlignment));
  RegisterRTTIType(TypeInfo(TLeftRight));
  RegisterRTTIType(TypeInfo(TBiDiMode));
  RegisterRTTIType(TypeInfo(TVerticalAlignment));
  RegisterRTTIType(TypeInfo(TTopBottom));
  RegisterRTTIType(TypeInfo(TShiftState));
  RegisterRTTIType(TypeInfo(THelpContext));
  RegisterRTTIType(TypeInfo(THelpType));
  // Begin of class EFileStreamError
  RegisterClassType(EFileStreamError, H);
  RegisterMethod(EFileStreamError,
       'constructor Create(ResStringRec: PResStringRec; const FileName: string);',
       @EFileStreamError.Create);
  // End of class EFileStreamError
  RegisterRTTIType(TypeInfo(TDuplicates));
  RegisterRTTIType(TypeInfo(TListNotification));
  RegisterRTTIType(TypeInfo(TListAssignOp));
  // Begin of class TListEnumerator
  RegisterClassType(TListEnumerator, H);
  RegisterMethod(TListEnumerator,
       'constructor Create(AList: TList);',
       @TListEnumerator.Create);
  RegisterStdMethodEx(TListEnumerator,'GetCurrent',TListEnumerator_GetCurrent,0,[typePOINTER]);
  RegisterStdMethodEx(TListEnumerator,'MoveNext',TListEnumerator_MoveNext,0,[typeBOOLEAN]);
  RegisterMethod(TListEnumerator,
       'function TListEnumerator__GetCurrent(Self:TListEnumerator):Pointer;',
       @TListEnumerator__GetCurrent, true);
  RegisterProperty(TListEnumerator,
       'property Current:Pointer read TListEnumerator__GetCurrent;');
  // End of class TListEnumerator
  // Begin of class TList
  RegisterClassType(TList, H);
  RegisterMethod(TList,
       'destructor Destroy; override;',
       @TList.Destroy);
  RegisterStdMethodEx(TList,'Add',TList_Add,1,[typePOINTER,typeINTEGER]);
  RegisterStdMethodEx(TList,'Clear',TList_Clear,0,[typeVARIANT]);
  RegisterStdMethodEx(TList,'Delete',TList_Delete,1,[typeINTEGER,typeVARIANT]);
  RegisterStdMethodEx(TList,'Error',TList_Error1,2,[typeSTRING,typeINTEGER,typeVARIANT]);
  RegisterStdMethodEx(TList,'Exchange',TList_Exchange,2,[typeINTEGER,typeINTEGER,typeVARIANT]);
  RegisterMethod(TList,
       'function Expand: TList;',
       @TList.Expand);
  RegisterStdMethodEx(TList,'Extract',TList_Extract,1,[typePOINTER,typePOINTER]);
  RegisterStdMethodEx(TList,'First',TList_First,0,[typePOINTER]);
  RegisterMethod(TList,
       'function GetEnumerator: TListEnumerator;',
       @TList.GetEnumerator);
  RegisterStdMethodEx(TList,'IndexOf',TList_IndexOf,1,[typePOINTER,typeINTEGER]);
  RegisterStdMethodEx(TList,'Insert',TList_Insert,2,[typeINTEGER,typePOINTER,typeVARIANT]);
  RegisterStdMethodEx(TList,'Last',TList_Last,0,[typePOINTER]);
  RegisterStdMethodEx(TList,'Move',TList_Move,2,[typeINTEGER,typeINTEGER,typeVARIANT]);
  RegisterStdMethodEx(TList,'Remove',TList_Remove,1,[typePOINTER,typeINTEGER]);
  RegisterStdMethodEx(TList,'Pack',TList_Pack,0,[typeVARIANT]);
  RegisterMethod(TList,
       'procedure Sort(Compare: TListSortCompare);',
       @TList.Sort);
  RegisterMethod(TList,
       'procedure Assign(ListA: TList; AOperator: TListAssignOp = laCopy; ListB: TList = nil);',
       @TList.Assign);
  RegisterMethod(TList,
       'function TList__GetCapacity(Self:TList):Integer;',
       @TList__GetCapacity, true);
  RegisterMethod(TList,
       'procedure TList__PutCapacity(Self:TList;const Value: Integer);',
       @TList__PutCapacity, true);
  RegisterProperty(TList,
       'property Capacity:Integer read TList__GetCapacity write TList__PutCapacity;');
  RegisterMethod(TList,
       'function TList__GetCount(Self:TList):Integer;',
       @TList__GetCount, true);
  RegisterMethod(TList,
       'procedure TList__PutCount(Self:TList;const Value: Integer);',
       @TList__PutCount, true);
  RegisterProperty(TList,
       'property Count:Integer read TList__GetCount write TList__PutCount;');
  RegisterMethod(TList,
       'function TList__GetItems(Self:TList;Index: Integer):Pointer;',
       @TList__GetItems, true);
  RegisterMethod(TList,
       'procedure TList__PutItems(Self:TList;Index: Integer;const Value: Pointer);',
       @TList__PutItems, true);
  RegisterProperty(TList,
       'property Items[Index: Integer]:Pointer read TList__GetItems write TList__PutItems;default;');
  RegisterMethod(TList,
       'function TList__GetList(Self:TList):PPointerList;',
       @TList__GetList, true);
  RegisterProperty(TList,
       'property List:PPointerList read TList__GetList;');
  RegisterMethod(TList,
       'constructor Create;',
       @TList.Create);
  // End of class TList
  // Begin of class TThreadList
  RegisterClassType(TThreadList, H);
  RegisterMethod(TThreadList,
       'constructor Create;',
       @TThreadList.Create);
  RegisterMethod(TThreadList,
       'destructor Destroy; override;',
       @TThreadList.Destroy);
  RegisterStdMethodEx(TThreadList,'Add',TThreadList_Add,1,[typePOINTER,typeVARIANT]);
  RegisterStdMethodEx(TThreadList,'Clear',TThreadList_Clear,0,[typeVARIANT]);
  RegisterMethod(TThreadList,
       'function  LockList: TList;',
       @TThreadList.LockList);
  RegisterStdMethodEx(TThreadList,'Remove',TThreadList_Remove,1,[typePOINTER,typeVARIANT]);
  RegisterStdMethodEx(TThreadList,'UnlockList',TThreadList_UnlockList,0,[typeVARIANT]);
  RegisterMethod(TThreadList,
       'function TThreadList__GetDuplicates(Self:TThreadList):TDuplicates;',
       @TThreadList__GetDuplicates, true);
  RegisterMethod(TThreadList,
       'procedure TThreadList__PutDuplicates(Self:TThreadList;const Value: TDuplicates);',
       @TThreadList__PutDuplicates, true);
  RegisterProperty(TThreadList,
       'property Duplicates:TDuplicates read TThreadList__GetDuplicates write TThreadList__PutDuplicates;');
  // End of class TThreadList
  // Begin of interface IInterfaceList
  RegisterInterfaceType('IInterfaceList',IInterfaceList,'IUnknown',IUnknown,H);
  RegisterInterfaceMethod(IInterfaceList,
       'function Get(Index: Integer): IInterface;');
  RegisterInterfaceMethod(IInterfaceList,
       'function GetCapacity: Integer;');
  RegisterInterfaceMethod(IInterfaceList,
       'function GetCount: Integer;');
  RegisterInterfaceMethod(IInterfaceList,
       'procedure Put(Index: Integer; const Item: IInterface);');
  RegisterInterfaceMethod(IInterfaceList,
       'procedure SetCapacity(NewCapacity: Integer);');
  RegisterInterfaceMethod(IInterfaceList,
       'procedure SetCount(NewCount: Integer);');
  RegisterInterfaceMethod(IInterfaceList,
       'procedure Clear;');
  RegisterInterfaceMethod(IInterfaceList,
       'procedure Delete(Index: Integer);');
  RegisterInterfaceMethod(IInterfaceList,
       'procedure Exchange(Index1, Index2: Integer);');
  RegisterInterfaceMethod(IInterfaceList,
       'function First: IInterface;');
  RegisterInterfaceMethod(IInterfaceList,
       'function IndexOf(const Item: IInterface): Integer;');
  RegisterInterfaceMethod(IInterfaceList,
       'function Add(const Item: IInterface): Integer;');
  RegisterInterfaceMethod(IInterfaceList,
       'procedure Insert(Index: Integer; const Item: IInterface);');
  RegisterInterfaceMethod(IInterfaceList,
       'function Last: IInterface;');
  RegisterInterfaceMethod(IInterfaceList,
       'function Remove(const Item: IInterface): Integer;');
  RegisterInterfaceMethod(IInterfaceList,
       'procedure Lock;');
  RegisterInterfaceMethod(IInterfaceList,
       'procedure Unlock;');
  RegisterInterfaceProperty(IInterfaceList,'property Capacity: Integer read GetCapacity write SetCapacity;');
  RegisterInterfaceProperty(IInterfaceList,'property Count: Integer read GetCount write SetCount;');
  RegisterInterfaceProperty(IInterfaceList,'property Items[Index: Integer]: IInterface read Get write Put; default;');
  // End of interface IInterfaceList
  // Begin of class TInterfaceListEnumerator
  RegisterClassType(TInterfaceListEnumerator, H);
  RegisterMethod(TInterfaceListEnumerator,
       'constructor Create(AInterfaceList: TInterfaceList);',
       @TInterfaceListEnumerator.Create);
  RegisterMethod(TInterfaceListEnumerator,
       'function GetCurrent: IInterface;',
       @TInterfaceListEnumerator.GetCurrent);
  RegisterStdMethodEx(TInterfaceListEnumerator,'MoveNext',TInterfaceListEnumerator_MoveNext,0,[typeBOOLEAN]);
  RegisterMethod(TInterfaceListEnumerator,
       'function TInterfaceListEnumerator__GetCurrent(Self:TInterfaceListEnumerator):IInterface;',
       @TInterfaceListEnumerator__GetCurrent, true);
  RegisterProperty(TInterfaceListEnumerator,
       'property Current:IInterface read TInterfaceListEnumerator__GetCurrent;');
  // End of class TInterfaceListEnumerator
  // Begin of class TInterfaceList
  RegisterClassType(TInterfaceList, H);
  RegisterMethod(TInterfaceList,
       'constructor Create;',
       @TInterfaceList.Create);
  RegisterMethod(TInterfaceList,
       'destructor Destroy; override;',
       @TInterfaceList.Destroy);
  RegisterStdMethodEx(TInterfaceList,'Clear',TInterfaceList_Clear,0,[typeVARIANT]);
  RegisterStdMethodEx(TInterfaceList,'Delete',TInterfaceList_Delete,1,[typeINTEGER,typeVARIANT]);
  RegisterStdMethodEx(TInterfaceList,'Exchange',TInterfaceList_Exchange,2,[typeINTEGER,typeINTEGER,typeVARIANT]);
  RegisterMethod(TInterfaceList,
       'function Expand: TInterfaceList;',
       @TInterfaceList.Expand);
  RegisterMethod(TInterfaceList,
       'function First: IInterface;',
       @TInterfaceList.First);
  RegisterMethod(TInterfaceList,
       'function GetEnumerator: TInterfaceListEnumerator;',
       @TInterfaceList.GetEnumerator);
  RegisterMethod(TInterfaceList,
       'function IndexOf(const Item: IInterface): Integer;',
       @TInterfaceList.IndexOf);
  RegisterMethod(TInterfaceList,
       'function Add(const Item: IInterface): Integer;',
       @TInterfaceList.Add);
  RegisterMethod(TInterfaceList,
       'procedure Insert(Index: Integer; const Item: IInterface);',
       @TInterfaceList.Insert);
  RegisterMethod(TInterfaceList,
       'function Last: IInterface;',
       @TInterfaceList.Last);
  RegisterMethod(TInterfaceList,
       'function Remove(const Item: IInterface): Integer;',
       @TInterfaceList.Remove);
  RegisterStdMethodEx(TInterfaceList,'Lock',TInterfaceList_Lock,0,[typeVARIANT]);
  RegisterStdMethodEx(TInterfaceList,'Unlock',TInterfaceList_Unlock,0,[typeVARIANT]);
  RegisterMethod(TInterfaceList,
       'function TInterfaceList__GetCapacity(Self:TInterfaceList):Integer;',
       @TInterfaceList__GetCapacity, true);
  RegisterMethod(TInterfaceList,
       'procedure TInterfaceList__PutCapacity(Self:TInterfaceList;const Value: Integer);',
       @TInterfaceList__PutCapacity, true);
  RegisterProperty(TInterfaceList,
       'property Capacity:Integer read TInterfaceList__GetCapacity write TInterfaceList__PutCapacity;');
  RegisterMethod(TInterfaceList,
       'function TInterfaceList__GetCount(Self:TInterfaceList):Integer;',
       @TInterfaceList__GetCount, true);
  RegisterMethod(TInterfaceList,
       'procedure TInterfaceList__PutCount(Self:TInterfaceList;const Value: Integer);',
       @TInterfaceList__PutCount, true);
  RegisterProperty(TInterfaceList,
       'property Count:Integer read TInterfaceList__GetCount write TInterfaceList__PutCount;');
  RegisterMethod(TInterfaceList,
       'function TInterfaceList__GetItems(Self:TInterfaceList;Index: Integer):IInterface;',
       @TInterfaceList__GetItems, true);
  RegisterMethod(TInterfaceList,
       'procedure TInterfaceList__PutItems(Self:TInterfaceList;Index: Integer;const Value: IInterface);',
       @TInterfaceList__PutItems, true);
  RegisterProperty(TInterfaceList,
       'property Items[Index: Integer]:IInterface read TInterfaceList__GetItems write TInterfaceList__PutItems;default;');
  // End of class TInterfaceList
  // Begin of class TBits
  RegisterClassType(TBits, H);
  RegisterMethod(TBits,
       'destructor Destroy; override;',
       @TBits.Destroy);
  RegisterStdMethodEx(TBits,'OpenBit',TBits_OpenBit,0,[typeINTEGER]);
  RegisterMethod(TBits,
       'function TBits__GetBits(Self:TBits;Index: Integer):Boolean;',
       @TBits__GetBits, true);
  RegisterMethod(TBits,
       'procedure TBits__PutBits(Self:TBits;Index: Integer;const Value: Boolean);',
       @TBits__PutBits, true);
  RegisterProperty(TBits,
       'property Bits[Index: Integer]:Boolean read TBits__GetBits write TBits__PutBits;default;');
  RegisterMethod(TBits,
       'function TBits__GetSize(Self:TBits):Integer;',
       @TBits__GetSize, true);
  RegisterMethod(TBits,
       'procedure TBits__PutSize(Self:TBits;const Value: Integer);',
       @TBits__PutSize, true);
  RegisterProperty(TBits,
       'property Size:Integer read TBits__GetSize write TBits__PutSize;');
  RegisterMethod(TBits,
       'constructor Create;',
       @TBits.Create);
  // End of class TBits
  // Begin of class TPersistent
  RegisterClassType(TPersistent, H);
  RegisterMethod(TPersistent,
       'destructor Destroy; override;',
       @TPersistent.Destroy);
  RegisterMethod(TPersistent,
       'procedure Assign(Source: TPersistent); virtual;',
       @TPersistent.Assign);
  RegisterStdMethodEx(TPersistent,'GetNamePath',TPersistent_GetNamePath,0,[typeSTRING]);
  RegisterMethod(TPersistent,
       'constructor Create;',
       @TPersistent.Create);
  // End of class TPersistent
  // Begin of class TInterfacedPersistent
  RegisterClassType(TInterfacedPersistent, H);
  RegisterMethod(TInterfacedPersistent,
       'function QueryInterface(const IID: TGUID; out Obj): HResult; virtual; stdcall;',
       @TInterfacedPersistent.QueryInterface);
  RegisterStdMethodEx(TInterfacedPersistent,'AfterConstruction',TInterfacedPersistent_AfterConstruction,0,[typeVARIANT]);
  // CONSTRUCTOR IS NOT FOUND!!!
  // End of class TInterfacedPersistent
  // Begin of class TRecall
  RegisterClassType(TRecall, H);
  RegisterMethod(TRecall,
       'constructor Create(AStorage, AReference: TPersistent);',
       @TRecall.Create);
  RegisterMethod(TRecall,
       'destructor Destroy; override;',
       @TRecall.Destroy);
  RegisterStdMethodEx(TRecall,'Store',TRecall_Store,0,[typeVARIANT]);
  RegisterStdMethodEx(TRecall,'Forget',TRecall_Forget,0,[typeVARIANT]);
  RegisterMethod(TRecall,
       'function TRecall__GetReference(Self:TRecall):TPersistent;',
       @TRecall__GetReference, true);
  RegisterProperty(TRecall,
       'property Reference:TPersistent read TRecall__GetReference;');
  // End of class TRecall
  // Begin of class TCollectionItem
  RegisterClassType(TCollectionItem, H);
  RegisterMethod(TCollectionItem,
       'constructor Create(Collection: TCollection); virtual;',
       @TCollectionItem.Create);
  RegisterMethod(TCollectionItem,
       'destructor Destroy; override;',
       @TCollectionItem.Destroy);
  RegisterStdMethodEx(TCollectionItem,'GetNamePath',TCollectionItem_GetNamePath,0,[typeSTRING]);
  RegisterMethod(TCollectionItem,
       'function TCollectionItem__GetCollection(Self:TCollectionItem):TCollection;',
       @TCollectionItem__GetCollection, true);
  RegisterMethod(TCollectionItem,
       'procedure TCollectionItem__PutCollection(Self:TCollectionItem;const Value: TCollection);',
       @TCollectionItem__PutCollection, true);
  RegisterProperty(TCollectionItem,
       'property Collection:TCollection read TCollectionItem__GetCollection write TCollectionItem__PutCollection;');
  RegisterMethod(TCollectionItem,
       'function TCollectionItem__GetID(Self:TCollectionItem):Integer;',
       @TCollectionItem__GetID, true);
  RegisterProperty(TCollectionItem,
       'property ID:Integer read TCollectionItem__GetID;');
  RegisterMethod(TCollectionItem,
       'function TCollectionItem__GetIndex(Self:TCollectionItem):Integer;',
       @TCollectionItem__GetIndex, true);
  RegisterMethod(TCollectionItem,
       'procedure TCollectionItem__PutIndex(Self:TCollectionItem;const Value: Integer);',
       @TCollectionItem__PutIndex, true);
  RegisterProperty(TCollectionItem,
       'property Index:Integer read TCollectionItem__GetIndex write TCollectionItem__PutIndex;');
  RegisterMethod(TCollectionItem,
       'function TCollectionItem__GetDisplayName(Self:TCollectionItem):string;',
       @TCollectionItem__GetDisplayName, true);
  RegisterMethod(TCollectionItem,
       'procedure TCollectionItem__PutDisplayName(Self:TCollectionItem;const Value: string);',
       @TCollectionItem__PutDisplayName, true);
  RegisterProperty(TCollectionItem,
       'property DisplayName:string read TCollectionItem__GetDisplayName write TCollectionItem__PutDisplayName;');
  // End of class TCollectionItem
  RegisterRTTIType(TypeInfo(TCollectionNotification));
  // Begin of class TCollectionEnumerator
  RegisterClassType(TCollectionEnumerator, H);
  RegisterMethod(TCollectionEnumerator,
       'constructor Create(ACollection: TCollection);',
       @TCollectionEnumerator.Create);
  RegisterMethod(TCollectionEnumerator,
       'function GetCurrent: TCollectionItem;',
       @TCollectionEnumerator.GetCurrent);
  RegisterStdMethodEx(TCollectionEnumerator,'MoveNext',TCollectionEnumerator_MoveNext,0,[typeBOOLEAN]);
  RegisterMethod(TCollectionEnumerator,
       'function TCollectionEnumerator__GetCurrent(Self:TCollectionEnumerator):TCollectionItem;',
       @TCollectionEnumerator__GetCurrent, true);
  RegisterProperty(TCollectionEnumerator,
       'property Current:TCollectionItem read TCollectionEnumerator__GetCurrent;');
  // End of class TCollectionEnumerator
  // Begin of class TCollection
  RegisterClassType(TCollection, H);
  RegisterMethod(TCollection,
       'constructor Create(ItemClass: TCollectionItemClass);',
       @TCollection.Create);
  RegisterMethod(TCollection,
       'destructor Destroy; override;',
       @TCollection.Destroy);
  RegisterMethod(TCollection,
       'function Owner: TPersistent;',
       @TCollection.Owner);
  RegisterMethod(TCollection,
       'function Add: TCollectionItem;',
       @TCollection.Add);
  RegisterMethod(TCollection,
       'procedure Assign(Source: TPersistent); override;',
       @TCollection.Assign);
  RegisterStdMethodEx(TCollection,'BeginUpdate',TCollection_BeginUpdate,0,[typeVARIANT]);
  RegisterStdMethodEx(TCollection,'Clear',TCollection_Clear,0,[typeVARIANT]);
  RegisterStdMethodEx(TCollection,'Delete',TCollection_Delete,1,[typeINTEGER,typeVARIANT]);
  RegisterStdMethodEx(TCollection,'EndUpdate',TCollection_EndUpdate,0,[typeVARIANT]);
  RegisterMethod(TCollection,
       'function FindItemID(ID: Integer): TCollectionItem;',
       @TCollection.FindItemID);
  RegisterMethod(TCollection,
       'function GetEnumerator: TCollectionEnumerator;',
       @TCollection.GetEnumerator);
  RegisterStdMethodEx(TCollection,'GetNamePath',TCollection_GetNamePath,0,[typeSTRING]);
  RegisterMethod(TCollection,
       'function Insert(Index: Integer): TCollectionItem;',
       @TCollection.Insert);
  RegisterMethod(TCollection,
       'function TCollection__GetCapacity(Self:TCollection):Integer;',
       @TCollection__GetCapacity, true);
  RegisterMethod(TCollection,
       'procedure TCollection__PutCapacity(Self:TCollection;const Value: Integer);',
       @TCollection__PutCapacity, true);
  RegisterProperty(TCollection,
       'property Capacity:Integer read TCollection__GetCapacity write TCollection__PutCapacity;');
  RegisterMethod(TCollection,
       'function TCollection__GetCount(Self:TCollection):Integer;',
       @TCollection__GetCount, true);
  RegisterProperty(TCollection,
       'property Count:Integer read TCollection__GetCount;');
  RegisterMethod(TCollection,
       'function TCollection__GetItemClass(Self:TCollection):TCollectionItemClass;',
       @TCollection__GetItemClass, true);
  RegisterProperty(TCollection,
       'property ItemClass:TCollectionItemClass read TCollection__GetItemClass;');
  RegisterMethod(TCollection,
       'function TCollection__GetItems(Self:TCollection;Index: Integer):TCollectionItem;',
       @TCollection__GetItems, true);
  RegisterMethod(TCollection,
       'procedure TCollection__PutItems(Self:TCollection;Index: Integer;const Value: TCollectionItem);',
       @TCollection__PutItems, true);
  RegisterProperty(TCollection,
       'property Items[Index: Integer]:TCollectionItem read TCollection__GetItems write TCollection__PutItems;');
  // End of class TCollection
  // Begin of class TOwnedCollection
  RegisterClassType(TOwnedCollection, H);
  RegisterMethod(TOwnedCollection,
       'constructor Create(AOwner: TPersistent; ItemClass: TCollectionItemClass);',
       @TOwnedCollection.Create);
  // End of class TOwnedCollection
  // Begin of interface IStringsAdapter
  RegisterInterfaceType('IStringsAdapter',IStringsAdapter,'IUnknown',IUnknown,H);
  RegisterInterfaceMethod(IStringsAdapter,
       'procedure ReferenceStrings(S: TStrings);');
  RegisterInterfaceMethod(IStringsAdapter,
       'procedure ReleaseStrings;');
  // End of interface IStringsAdapter
  RegisterRTTIType(TypeInfo(TStringsDefined));
  // Begin of class TStringsEnumerator
  RegisterClassType(TStringsEnumerator, H);
  RegisterMethod(TStringsEnumerator,
       'constructor Create(AStrings: TStrings);',
       @TStringsEnumerator.Create);
  RegisterStdMethodEx(TStringsEnumerator,'GetCurrent',TStringsEnumerator_GetCurrent,0,[typeSTRING]);
  RegisterStdMethodEx(TStringsEnumerator,'MoveNext',TStringsEnumerator_MoveNext,0,[typeBOOLEAN]);
  RegisterMethod(TStringsEnumerator,
       'function TStringsEnumerator__GetCurrent(Self:TStringsEnumerator):string;',
       @TStringsEnumerator__GetCurrent, true);
  RegisterProperty(TStringsEnumerator,
       'property Current:string read TStringsEnumerator__GetCurrent;');
  // End of class TStringsEnumerator
  // Begin of class TStrings
  RegisterClassType(TStrings, H);
  RegisterMethod(TStrings,
       'destructor Destroy; override;',
       @TStrings.Destroy);
  RegisterStdMethodEx(TStrings,'Add',TStrings_Add,1,[typeSTRING,typeINTEGER]);
  RegisterMethod(TStrings,
       'function AddObject(const S: string; AObject: TObject): Integer; virtual;',
       @TStrings.AddObject);
  RegisterStdMethodEx(TStrings,'Append',TStrings_Append,1,[typeSTRING,typeVARIANT]);
  RegisterMethod(TStrings,
       'procedure AddStrings(Strings: TStrings); virtual;',
       @TStrings.AddStrings);
  RegisterMethod(TStrings,
       'procedure Assign(Source: TPersistent); override;',
       @TStrings.Assign);
  RegisterStdMethodEx(TStrings,'BeginUpdate',TStrings_BeginUpdate,0,[typeVARIANT]);
  RegisterStdMethodEx(TStrings,'EndUpdate',TStrings_EndUpdate,0,[typeVARIANT]);
  RegisterMethod(TStrings,
       'function Equals(Strings: TStrings): Boolean;',
       @TStrings.Equals);
  RegisterStdMethodEx(TStrings,'Exchange',TStrings_Exchange,2,[typeINTEGER,typeINTEGER,typeVARIANT]);
  RegisterMethod(TStrings,
       'function GetEnumerator: TStringsEnumerator;',
       @TStrings.GetEnumerator);
  RegisterMethod(TStrings,
       'function GetText: PChar; virtual;',
       @TStrings.GetText);
  RegisterStdMethodEx(TStrings,'IndexOf',TStrings_IndexOf,1,[typeSTRING,typeINTEGER]);
  RegisterStdMethodEx(TStrings,'IndexOfName',TStrings_IndexOfName,1,[typeSTRING,typeINTEGER]);
  RegisterMethod(TStrings,
       'function IndexOfObject(AObject: TObject): Integer; virtual;',
       @TStrings.IndexOfObject);
  RegisterMethod(TStrings,
       'procedure InsertObject(Index: Integer; const S: string;      AObject: TObject); virtual;',
       @TStrings.InsertObject);
  RegisterStdMethodEx(TStrings,'LoadFromFile',TStrings_LoadFromFile,1,[typeSTRING,typeVARIANT]);
  RegisterMethod(TStrings,
       'procedure LoadFromStream(Stream: TStream); virtual;',
       @TStrings.LoadFromStream);
  RegisterStdMethodEx(TStrings,'Move',TStrings_Move,2,[typeINTEGER,typeINTEGER,typeVARIANT]);
  RegisterStdMethodEx(TStrings,'SaveToFile',TStrings_SaveToFile,1,[typeSTRING,typeVARIANT]);
  RegisterMethod(TStrings,
       'procedure SaveToStream(Stream: TStream); virtual;',
       @TStrings.SaveToStream);
  RegisterMethod(TStrings,
       'procedure SetText(Text: PChar); virtual;',
       @TStrings.SetText);
  RegisterMethod(TStrings,
       'function TStrings__GetCapacity(Self:TStrings):Integer;',
       @TStrings__GetCapacity, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutCapacity(Self:TStrings;const Value: Integer);',
       @TStrings__PutCapacity, true);
  RegisterProperty(TStrings,
       'property Capacity:Integer read TStrings__GetCapacity write TStrings__PutCapacity;');
  RegisterMethod(TStrings,
       'function TStrings__GetCommaText(Self:TStrings):string;',
       @TStrings__GetCommaText, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutCommaText(Self:TStrings;const Value: string);',
       @TStrings__PutCommaText, true);
  RegisterProperty(TStrings,
       'property CommaText:string read TStrings__GetCommaText write TStrings__PutCommaText;');
  RegisterMethod(TStrings,
       'function TStrings__GetCount(Self:TStrings):Integer;',
       @TStrings__GetCount, true);
  RegisterProperty(TStrings,
       'property Count:Integer read TStrings__GetCount;');
  RegisterMethod(TStrings,
       'function TStrings__GetDelimiter(Self:TStrings):Char;',
       @TStrings__GetDelimiter, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutDelimiter(Self:TStrings;const Value: Char);',
       @TStrings__PutDelimiter, true);
  RegisterProperty(TStrings,
       'property Delimiter:Char read TStrings__GetDelimiter write TStrings__PutDelimiter;');
  RegisterMethod(TStrings,
       'function TStrings__GetDelimitedText(Self:TStrings):string;',
       @TStrings__GetDelimitedText, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutDelimitedText(Self:TStrings;const Value: string);',
       @TStrings__PutDelimitedText, true);
  RegisterProperty(TStrings,
       'property DelimitedText:string read TStrings__GetDelimitedText write TStrings__PutDelimitedText;');
  RegisterMethod(TStrings,
       'function TStrings__GetLineBreak(Self:TStrings):string;',
       @TStrings__GetLineBreak, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutLineBreak(Self:TStrings;const Value: string);',
       @TStrings__PutLineBreak, true);
  RegisterProperty(TStrings,
       'property LineBreak:string read TStrings__GetLineBreak write TStrings__PutLineBreak;');
  RegisterMethod(TStrings,
       'function TStrings__GetNames(Self:TStrings;Index: Integer):string;',
       @TStrings__GetNames, true);
  RegisterProperty(TStrings,
       'property Names[Index: Integer]:string read TStrings__GetNames;');
  RegisterMethod(TStrings,
       'function TStrings__GetObjects(Self:TStrings;Index: Integer):TObject;',
       @TStrings__GetObjects, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutObjects(Self:TStrings;Index: Integer;const Value: TObject);',
       @TStrings__PutObjects, true);
  RegisterProperty(TStrings,
       'property Objects[Index: Integer]:TObject read TStrings__GetObjects write TStrings__PutObjects;');
  RegisterMethod(TStrings,
       'function TStrings__GetQuoteChar(Self:TStrings):Char;',
       @TStrings__GetQuoteChar, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutQuoteChar(Self:TStrings;const Value: Char);',
       @TStrings__PutQuoteChar, true);
  RegisterProperty(TStrings,
       'property QuoteChar:Char read TStrings__GetQuoteChar write TStrings__PutQuoteChar;');
  RegisterMethod(TStrings,
       'function TStrings__GetValues(Self:TStrings;const Name: string):string;',
       @TStrings__GetValues, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutValues(Self:TStrings;const Name: string;const Value: string);',
       @TStrings__PutValues, true);
  RegisterProperty(TStrings,
       'property Values[const Name: string]:string read TStrings__GetValues write TStrings__PutValues;');
  RegisterMethod(TStrings,
       'function TStrings__GetValueFromIndex(Self:TStrings;Index: Integer):string;',
       @TStrings__GetValueFromIndex, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutValueFromIndex(Self:TStrings;Index: Integer;const Value: string);',
       @TStrings__PutValueFromIndex, true);
  RegisterProperty(TStrings,
       'property ValueFromIndex[Index: Integer]:string read TStrings__GetValueFromIndex write TStrings__PutValueFromIndex;');
  RegisterMethod(TStrings,
       'function TStrings__GetNameValueSeparator(Self:TStrings):Char;',
       @TStrings__GetNameValueSeparator, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutNameValueSeparator(Self:TStrings;const Value: Char);',
       @TStrings__PutNameValueSeparator, true);
  RegisterProperty(TStrings,
       'property NameValueSeparator:Char read TStrings__GetNameValueSeparator write TStrings__PutNameValueSeparator;');
  RegisterMethod(TStrings,
       'function TStrings__GetStrictDelimiter(Self:TStrings):Boolean;',
       @TStrings__GetStrictDelimiter, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutStrictDelimiter(Self:TStrings;const Value: Boolean);',
       @TStrings__PutStrictDelimiter, true);
  RegisterProperty(TStrings,
       'property StrictDelimiter:Boolean read TStrings__GetStrictDelimiter write TStrings__PutStrictDelimiter;');
  RegisterMethod(TStrings,
       'function TStrings__GetStrings(Self:TStrings;Index: Integer):string;',
       @TStrings__GetStrings, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutStrings(Self:TStrings;Index: Integer;const Value: string);',
       @TStrings__PutStrings, true);
  RegisterProperty(TStrings,
       'property Strings[Index: Integer]:string read TStrings__GetStrings write TStrings__PutStrings;default;');
  RegisterMethod(TStrings,
       'function TStrings__GetText(Self:TStrings):string;',
       @TStrings__GetText, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutText(Self:TStrings;const Value: string);',
       @TStrings__PutText, true);
  RegisterProperty(TStrings,
       'property Text:string read TStrings__GetText write TStrings__PutText;');
  RegisterMethod(TStrings,
       'function TStrings__GetStringsAdapter(Self:TStrings):IStringsAdapter;',
       @TStrings__GetStringsAdapter, true);
  RegisterMethod(TStrings,
       'procedure TStrings__PutStringsAdapter(Self:TStrings;const Value: IStringsAdapter);',
       @TStrings__PutStringsAdapter, true);
  RegisterProperty(TStrings,
       'property StringsAdapter:IStringsAdapter read TStrings__GetStringsAdapter write TStrings__PutStringsAdapter;');
  RegisterMethod(TStrings,
       'constructor Create;',
       @TStrings.Create);
  // End of class TStrings
  // Begin of class TStringList
  RegisterClassType(TStringList, H);
  RegisterMethod(TStringList,
       'destructor Destroy; override;',
       @TStringList.Destroy);
  RegisterStdMethodEx(TStringList,'Add',TStringList_Add,1,[typeSTRING,typeINTEGER]);
  RegisterMethod(TStringList,
       'function AddObject(const S: string; AObject: TObject): Integer; override;',
       @TStringList.AddObject);
  RegisterStdMethodEx(TStringList,'Clear',TStringList_Clear,0,[typeVARIANT]);
  RegisterStdMethodEx(TStringList,'Delete',TStringList_Delete,1,[typeINTEGER,typeVARIANT]);
  RegisterStdMethodEx(TStringList,'Exchange',TStringList_Exchange,2,[typeINTEGER,typeINTEGER,typeVARIANT]);
  RegisterMethod(TStringList,
       'function Find(const S: string; var Index: Integer): Boolean; virtual;',
       @TStringList.Find);
  RegisterStdMethodEx(TStringList,'IndexOf',TStringList_IndexOf,1,[typeSTRING,typeINTEGER]);
  RegisterStdMethodEx(TStringList,'Insert',TStringList_Insert,2,[typeINTEGER,typeSTRING,typeVARIANT]);
  RegisterMethod(TStringList,
       'procedure InsertObject(Index: Integer; const S: string;      AObject: TObject); override;',
       @TStringList.InsertObject);
  RegisterStdMethodEx(TStringList,'Sort',TStringList_Sort,0,[typeVARIANT]);
  RegisterMethod(TStringList,
       'procedure CustomSort(Compare: TStringListSortCompare); virtual;',
       @TStringList.CustomSort);
  RegisterMethod(TStringList,
       'function TStringList__GetDuplicates(Self:TStringList):TDuplicates;',
       @TStringList__GetDuplicates, true);
  RegisterMethod(TStringList,
       'procedure TStringList__PutDuplicates(Self:TStringList;const Value: TDuplicates);',
       @TStringList__PutDuplicates, true);
  RegisterProperty(TStringList,
       'property Duplicates:TDuplicates read TStringList__GetDuplicates write TStringList__PutDuplicates;');
  RegisterMethod(TStringList,
       'function TStringList__GetSorted(Self:TStringList):Boolean;',
       @TStringList__GetSorted, true);
  RegisterMethod(TStringList,
       'procedure TStringList__PutSorted(Self:TStringList;const Value: Boolean);',
       @TStringList__PutSorted, true);
  RegisterProperty(TStringList,
       'property Sorted:Boolean read TStringList__GetSorted write TStringList__PutSorted;');
  RegisterMethod(TStringList,
       'function TStringList__GetCaseSensitive(Self:TStringList):Boolean;',
       @TStringList__GetCaseSensitive, true);
  RegisterMethod(TStringList,
       'procedure TStringList__PutCaseSensitive(Self:TStringList;const Value: Boolean);',
       @TStringList__PutCaseSensitive, true);
  RegisterProperty(TStringList,
       'property CaseSensitive:Boolean read TStringList__GetCaseSensitive write TStringList__PutCaseSensitive;');
  RegisterMethod(TStringList,
       'constructor Create;',
       @TStringList.Create);
  // End of class TStringList
  // Begin of class TStream
  RegisterClassType(TStream, H);
  RegisterStdMethod(TStream,'Seek',TStream_Seek3,2);
  RegisterMethod(TStream,
       'procedure ReadBuffer(var Buffer; Count: Longint);',
       @TStream.ReadBuffer);
  RegisterMethod(TStream,
       'procedure WriteBuffer(const Buffer; Count: Longint);',
       @TStream.WriteBuffer);
  RegisterMethod(TStream,
       'function CopyFrom(Source: TStream; Count: Int64): Int64;',
       @TStream.CopyFrom);
  RegisterMethod(TStream,
       'function ReadComponent(Instance: TComponent): TComponent;',
       @TStream.ReadComponent);
  RegisterMethod(TStream,
       'function ReadComponentRes(Instance: TComponent): TComponent;',
       @TStream.ReadComponentRes);
  RegisterMethod(TStream,
       'procedure WriteComponent(Instance: TComponent);',
       @TStream.WriteComponent);
  RegisterMethod(TStream,
       'procedure WriteComponentRes(const ResName: string; Instance: TComponent);',
       @TStream.WriteComponentRes);
  RegisterMethod(TStream,
       'procedure WriteDescendent(Instance, Ancestor: TComponent);',
       @TStream.WriteDescendent);
  RegisterMethod(TStream,
       'procedure WriteDescendentRes(const ResName: string; Instance, Ancestor: TComponent);',
       @TStream.WriteDescendentRes);
  RegisterMethod(TStream,
       'procedure WriteResourceHeader(const ResName: string; out FixupInfo: Integer);',
       @TStream.WriteResourceHeader);
  RegisterStdMethodEx(TStream,'FixupResourceHeader',TStream_FixupResourceHeader,1,[typeINTEGER,typeVARIANT]);
  RegisterStdMethodEx(TStream,'ReadResHeader',TStream_ReadResHeader,0,[typeVARIANT]);
  RegisterMethod(TStream,
       'function TStream__GetPosition(Self:TStream):Int64;',
       @TStream__GetPosition, true);
  RegisterMethod(TStream,
       'procedure TStream__PutPosition(Self:TStream;const Value: Int64);',
       @TStream__PutPosition, true);
  RegisterProperty(TStream,
       'property Position:Int64 read TStream__GetPosition write TStream__PutPosition;');
  RegisterMethod(TStream,
       'function TStream__GetSize(Self:TStream):Int64;',
       @TStream__GetSize, true);
  RegisterMethod(TStream,
       'procedure TStream__PutSize(Self:TStream;const Value: Int64);',
       @TStream__PutSize, true);
  RegisterProperty(TStream,
       'property Size:Int64 read TStream__GetSize write TStream__PutSize;');
  RegisterMethod(TStream,
       'constructor Create;',
       @TStream.Create);
  // End of class TStream
  // Begin of interface IStreamPersist
  RegisterInterfaceType('IStreamPersist',IStreamPersist,'IUnknown',IUnknown,H);
  RegisterInterfaceMethod(IStreamPersist,
       'procedure LoadFromStream(Stream: TStream);');
  RegisterInterfaceMethod(IStreamPersist,
       'procedure SaveToStream(Stream: TStream);');
  // End of interface IStreamPersist
  // Begin of class THandleStream
  RegisterClassType(THandleStream, H);
  RegisterMethod(THandleStream,
       'constructor Create(AHandle: Integer);',
       @THandleStream.Create);
  RegisterMethod(THandleStream,
       'function Read(var Buffer; Count: Longint): Longint; override;',
       @THandleStream.Read);
  RegisterMethod(THandleStream,
       'function Write(const Buffer; Count: Longint): Longint; override;',
       @THandleStream.Write);
  RegisterMethod(THandleStream,
       'function Seek(const Offset: Int64; Origin: TSeekOrigin): Int64; override;',
       @THandleStream.Seek);
  RegisterMethod(THandleStream,
       'function THandleStream__GetHandle(Self:THandleStream):Integer;',
       @THandleStream__GetHandle, true);
  RegisterProperty(THandleStream,
       'property Handle:Integer read THandleStream__GetHandle;');
  // End of class THandleStream
  // Begin of class TFileStream
  RegisterClassType(TFileStream, H);
end;
initialization
  RegisterIMP_Classes;
end.
