unit DataAbstract4_Async;

{----------------------------------------------------------------------------}
{ This unit was automatically generated by the RemObjects SDK after reading  }
{ the RODL file associated with this project .                               }
{                                                                            }
{ Do not modify this unit manually, or your changes will be lost when this   }
{ unit is regenerated the next time you compile the project.                 }
{----------------------------------------------------------------------------}

{$I DataAbstract.inc}

interface

uses
  {vcl:} Classes, TypInfo,
  {RemObjects:} uROXMLIntf, uROClasses, uROTypes, uROClientIntf, uROAsync,
  {Project:} DataAbstract4_Intf;

type
  { IDataAbstractService_Async }
  IDataAbstractService_Async = interface(IROAsyncInterface)
    ['{B4C1D84D-1C6F-4E5A-8839-0C9F7EA5431B}']
    procedure Invoke_GetSchema(const aFilter: Utf8String);
    procedure Invoke_GetData(const aTableNameArray: StringArray; const aTableRequestInfoArray: TableRequestInfoArray);
    procedure Invoke_UpdateData(const aDelta: Binary);
    procedure Invoke_ExecuteCommand(const aCommandName: Utf8String; const aParameterArray: DataParameterArray);
    procedure Invoke_ExecuteCommandEx(const aCommandName: Utf8String; const aInputParameters: DataParameterArray);
    procedure Invoke_GetTableSchema(const aTableNameArray: StringArray);
    procedure Invoke_GetCommandSchema(const aCommandNameArray: StringArray);
    procedure Invoke_SQLGetData(const aSQLText: Utf8String; const aIncludeSchema: Boolean; const aMaxRecords: Integer);
    procedure Invoke_SQLExecuteCommand(const aSQLText: Utf8String);
    procedure Invoke_GetDatasetScripts(const DatasetNames: Utf8String);
    procedure Invoke_RegisterForDataChangeNotification(const aTableName: Utf8String);
    procedure Invoke_UnregisterForDataChangeNotification(const aTableName: Utf8String);
    function Retrieve_GetSchema: Utf8String;
    function Retrieve_GetData: Binary;
    function Retrieve_UpdateData: Binary;
    function Retrieve_ExecuteCommand: Integer;
    function Retrieve_ExecuteCommandEx(out aOutputParameters: DataParameterArray): Integer;
    function Retrieve_GetTableSchema: Utf8String;
    function Retrieve_GetCommandSchema: Utf8String;
    function Retrieve_SQLGetData: Binary;
    function Retrieve_SQLExecuteCommand: Integer;
    function Retrieve_GetDatasetScripts: Utf8String;
  end;

  { IBaseLoginService_Async }
  IBaseLoginService_Async = interface(IROAsyncInterface)
    ['{45A761A3-80E9-43E6-86BC-E96693551453}']
    procedure Invoke_Logout;
  end;

  { IMultiDbLoginService_Async }
  IMultiDbLoginService_Async = interface(IBaseLoginService_Async)
    ['{8EBB1878-ECD9-4F4E-8A87-E26D51FD0ADD}']
    procedure Invoke_Login(const aUserID: Utf8String; const aPassword: Utf8String; const aConnectionName: Utf8String);
    function Retrieve_Login(out aUserInfo: UserInfo): Boolean;
  end;

  { IMultiDbLoginServiceV5_Async }
  IMultiDbLoginServiceV5_Async = interface(IMultiDbLoginService_Async)
    ['{292C3E8B-B263-4D95-9EE6-41DA014ACDF3}']
    procedure Invoke_GetConnectionNames;
    procedure Invoke_GetDefaultConnectionName;
    function Retrieve_GetConnectionNames: StringArray;
    function Retrieve_GetDefaultConnectionName: Utf8String;
  end;

  { ISimpleLoginService_Async }
  ISimpleLoginService_Async = interface(IBaseLoginService_Async)
    ['{74BC5406-7AA7-45CD-8012-193C38DF62E9}']
    procedure Invoke_Login(const aUserID: Utf8String; const aPassword: Utf8String);
    function Retrieve_Login(out aUserInfo: UserInfo): Boolean;
  end;

  { CoDataAbstractService_Async }
  CoDataAbstractService_Async = class
    class function Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IDataAbstractService_Async;
  end;

  { CoBaseLoginService_Async }
  CoBaseLoginService_Async = class
    class function Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IBaseLoginService_Async;
  end;

  { CoMultiDbLoginService_Async }
  CoMultiDbLoginService_Async = class
    class function Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IMultiDbLoginService_Async;
  end;

  { CoMultiDbLoginServiceV5_Async }
  CoMultiDbLoginServiceV5_Async = class
    class function Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IMultiDbLoginServiceV5_Async;
  end;

  { CoSimpleLoginService_Async }
  CoSimpleLoginService_Async = class
    class function Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): ISimpleLoginService_Async;
  end;

  { TDataAbstractService_AsyncProxy }
  TDataAbstractService_AsyncProxy = class(TROAsyncProxy, IDataAbstractService_Async)
  private
  protected
    function __GetInterfaceName:string; override;

    procedure Invoke_GetSchema(const aFilter: Utf8String);
    procedure Invoke_GetData(const aTableNameArray: StringArray; const aTableRequestInfoArray: TableRequestInfoArray);
    procedure Invoke_UpdateData(const aDelta: Binary);
    procedure Invoke_ExecuteCommand(const aCommandName: Utf8String; const aParameterArray: DataParameterArray);
    procedure Invoke_ExecuteCommandEx(const aCommandName: Utf8String; const aInputParameters: DataParameterArray);
    procedure Invoke_GetTableSchema(const aTableNameArray: StringArray);
    procedure Invoke_GetCommandSchema(const aCommandNameArray: StringArray);
    procedure Invoke_SQLGetData(const aSQLText: Utf8String; const aIncludeSchema: Boolean; const aMaxRecords: Integer);
    procedure Invoke_SQLExecuteCommand(const aSQLText: Utf8String);
    procedure Invoke_GetDatasetScripts(const DatasetNames: Utf8String);
    procedure Invoke_RegisterForDataChangeNotification(const aTableName: Utf8String);
    procedure Invoke_UnregisterForDataChangeNotification(const aTableName: Utf8String);
    function Retrieve_GetSchema: Utf8String;
    function Retrieve_GetData: Binary;
    function Retrieve_UpdateData: Binary;
    function Retrieve_ExecuteCommand: Integer;
    function Retrieve_ExecuteCommandEx(out aOutputParameters: DataParameterArray): Integer;
    function Retrieve_GetTableSchema: Utf8String;
    function Retrieve_GetCommandSchema: Utf8String;
    function Retrieve_SQLGetData: Binary;
    function Retrieve_SQLExecuteCommand: Integer;
    function Retrieve_GetDatasetScripts: Utf8String;
  end;

  { TBaseLoginService_AsyncProxy }
  TBaseLoginService_AsyncProxy = class(TROAsyncProxy, IBaseLoginService_Async)
  private
  protected
    function __GetInterfaceName:string; override;

    procedure Invoke_Logout;
  end;

  { TMultiDbLoginService_AsyncProxy }
  TMultiDbLoginService_AsyncProxy = class(TBaseLoginService_AsyncProxy, IMultiDbLoginService_Async)
  private
  protected
    function __GetInterfaceName:string; override;

    procedure Invoke_Login(const aUserID: Utf8String; const aPassword: Utf8String; const aConnectionName: Utf8String);
    function Retrieve_Login(out aUserInfo: UserInfo): Boolean;
  end;

  { TMultiDbLoginServiceV5_AsyncProxy }
  TMultiDbLoginServiceV5_AsyncProxy = class(TMultiDbLoginService_AsyncProxy, IMultiDbLoginServiceV5_Async)
  private
  protected
    function __GetInterfaceName:string; override;

    procedure Invoke_GetConnectionNames;
    procedure Invoke_GetDefaultConnectionName;
    function Retrieve_GetConnectionNames: StringArray;
    function Retrieve_GetDefaultConnectionName: Utf8String;
  end;

  { TSimpleLoginService_AsyncProxy }
  TSimpleLoginService_AsyncProxy = class(TBaseLoginService_AsyncProxy, ISimpleLoginService_Async)
  private
  protected
    function __GetInterfaceName:string; override;

    procedure Invoke_Login(const aUserID: Utf8String; const aPassword: Utf8String);
    function Retrieve_Login(out aUserInfo: UserInfo): Boolean;
  end;

implementation

uses
  {vcl:} SysUtils;

{ CoDataAbstractService }

class function CoDataAbstractService_Async.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IDataAbstractService_Async;
begin
  result := TDataAbstractService_AsyncProxy.Create(aMessage, aTransportChannel);
end;

{ TDataAbstractService_AsyncProxy }

function TDataAbstractService_AsyncProxy.__GetInterfaceName:string;
begin
  result := 'DataAbstractService';
end;

procedure TDataAbstractService_AsyncProxy.Invoke_GetSchema(const aFilter: Utf8String);
begin
  __AssertProxyNotBusy('GetSchema');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetSchema');
  __Message.Write('aFilter', TypeInfo(Utf8String), aFilter, []);
  __DispatchAsyncRequest('GetSchema',__Message);
    __Message.UnsetAttributes(__TransportChannel);
end;

function TDataAbstractService_AsyncProxy.Retrieve_GetSchema: Utf8String;
var __response:TStream;
begin
  __response := __RetrieveAsyncResponse('GetSchema');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(Utf8String), Result, []);

  __response.Free();
end;

procedure TDataAbstractService_AsyncProxy.Invoke_GetData(const aTableNameArray: StringArray; const aTableRequestInfoArray: TableRequestInfoArray);
begin
  __AssertProxyNotBusy('GetData');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetData');
  __Message.Write('aTableNameArray', TypeInfo(StringArray), aTableNameArray, []);
  __Message.Write('aTableRequestInfoArray', TypeInfo(TableRequestInfoArray), aTableRequestInfoArray, []);
  __DispatchAsyncRequest('GetData',__Message);
    __Message.UnsetAttributes(__TransportChannel);
end;

function TDataAbstractService_AsyncProxy.Retrieve_GetData: Binary;
var __response:TStream;
begin
  result := nil;
  __response := __RetrieveAsyncResponse('GetData');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(Binary), Result, []);

  __response.Free();
end;

procedure TDataAbstractService_AsyncProxy.Invoke_UpdateData(const aDelta: Binary);
begin
  __AssertProxyNotBusy('UpdateData');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'UpdateData');
  __Message.Write('aDelta', TypeInfo(Binary), aDelta, []);
  __DispatchAsyncRequest('UpdateData',__Message);
    __Message.UnsetAttributes(__TransportChannel);
end;

function TDataAbstractService_AsyncProxy.Retrieve_UpdateData: Binary;
var __response:TStream;
begin
  result := nil;
  __response := __RetrieveAsyncResponse('UpdateData');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(Binary), Result, []);

  __response.Free();
end;

procedure TDataAbstractService_AsyncProxy.Invoke_ExecuteCommand(const aCommandName: Utf8String; const aParameterArray: DataParameterArray);
begin
  __AssertProxyNotBusy('ExecuteCommand');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'ExecuteCommand');
  __Message.Write('aCommandName', TypeInfo(Utf8String), aCommandName, []);
  __Message.Write('aParameterArray', TypeInfo(DataParameterArray), aParameterArray, []);
  __DispatchAsyncRequest('ExecuteCommand',__Message);
    __Message.UnsetAttributes(__TransportChannel);
end;

function TDataAbstractService_AsyncProxy.Retrieve_ExecuteCommand: Integer;
var __response:TStream;
begin
  __response := __RetrieveAsyncResponse('ExecuteCommand');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(Integer), Result, []);

  __response.Free();
end;

procedure TDataAbstractService_AsyncProxy.Invoke_ExecuteCommandEx(const aCommandName: Utf8String; const aInputParameters: DataParameterArray);
begin
  __AssertProxyNotBusy('ExecuteCommandEx');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'ExecuteCommandEx');
  __Message.Write('aCommandName', TypeInfo(Utf8String), aCommandName, []);
  __Message.Write('aInputParameters', TypeInfo(DataParameterArray), aInputParameters, []);
  __DispatchAsyncRequest('ExecuteCommandEx',__Message);
    __Message.UnsetAttributes(__TransportChannel);
end;

function TDataAbstractService_AsyncProxy.Retrieve_ExecuteCommandEx(out aOutputParameters: DataParameterArray): Integer;
var __response:TStream;
begin
  aOutputParameters := nil;
  __response := __RetrieveAsyncResponse('ExecuteCommandEx');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(Integer), Result, []);
  __Message.Read('aOutputParameters', TypeInfo(DataParameterArray), aOutputParameters, []);

  __response.Free();
end;

procedure TDataAbstractService_AsyncProxy.Invoke_GetTableSchema(const aTableNameArray: StringArray);
begin
  __AssertProxyNotBusy('GetTableSchema');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetTableSchema');
  __Message.Write('aTableNameArray', TypeInfo(StringArray), aTableNameArray, []);
  __DispatchAsyncRequest('GetTableSchema',__Message);
    __Message.UnsetAttributes(__TransportChannel);
end;

function TDataAbstractService_AsyncProxy.Retrieve_GetTableSchema: Utf8String;
var __response:TStream;
begin
  __response := __RetrieveAsyncResponse('GetTableSchema');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(Utf8String), Result, []);

  __response.Free();
end;

procedure TDataAbstractService_AsyncProxy.Invoke_GetCommandSchema(const aCommandNameArray: StringArray);
begin
  __AssertProxyNotBusy('GetCommandSchema');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetCommandSchema');
  __Message.Write('aCommandNameArray', TypeInfo(StringArray), aCommandNameArray, []);
  __DispatchAsyncRequest('GetCommandSchema',__Message);
    __Message.UnsetAttributes(__TransportChannel);
end;

function TDataAbstractService_AsyncProxy.Retrieve_GetCommandSchema: Utf8String;
var __response:TStream;
begin
  __response := __RetrieveAsyncResponse('GetCommandSchema');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(Utf8String), Result, []);

  __response.Free();
end;

procedure TDataAbstractService_AsyncProxy.Invoke_SQLGetData(const aSQLText: Utf8String; const aIncludeSchema: Boolean; const aMaxRecords: Integer);
begin
  __AssertProxyNotBusy('SQLGetData');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'SQLGetData');
  __Message.Write('aSQLText', TypeInfo(Utf8String), aSQLText, []);
  __Message.Write('aIncludeSchema', TypeInfo(Boolean), aIncludeSchema, []);
  __Message.Write('aMaxRecords', TypeInfo(Integer), aMaxRecords, []);
  __DispatchAsyncRequest('SQLGetData',__Message);
    __Message.UnsetAttributes(__TransportChannel);
end;

function TDataAbstractService_AsyncProxy.Retrieve_SQLGetData: Binary;
var __response:TStream;
begin
  result := nil;
  __response := __RetrieveAsyncResponse('SQLGetData');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(Binary), Result, []);

  __response.Free();
end;

procedure TDataAbstractService_AsyncProxy.Invoke_SQLExecuteCommand(const aSQLText: Utf8String);
begin
  __AssertProxyNotBusy('SQLExecuteCommand');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'SQLExecuteCommand');
  __Message.Write('aSQLText', TypeInfo(Utf8String), aSQLText, []);
  __DispatchAsyncRequest('SQLExecuteCommand',__Message);
    __Message.UnsetAttributes(__TransportChannel);
end;

function TDataAbstractService_AsyncProxy.Retrieve_SQLExecuteCommand: Integer;
var __response:TStream;
begin
  __response := __RetrieveAsyncResponse('SQLExecuteCommand');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(Integer), Result, []);

  __response.Free();
end;

procedure TDataAbstractService_AsyncProxy.Invoke_GetDatasetScripts(const DatasetNames: Utf8String);
begin
  __AssertProxyNotBusy('GetDatasetScripts');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetDatasetScripts');
  __Message.Write('DatasetNames', TypeInfo(Utf8String), DatasetNames, []);
  __DispatchAsyncRequest('GetDatasetScripts',__Message);
    __Message.UnsetAttributes(__TransportChannel);
end;

function TDataAbstractService_AsyncProxy.Retrieve_GetDatasetScripts: Utf8String;
var __response:TStream;
begin
  __response := __RetrieveAsyncResponse('GetDatasetScripts');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(Utf8String), Result, []);

  __response.Free();
end;

procedure TDataAbstractService_AsyncProxy.Invoke_RegisterForDataChangeNotification(const aTableName: Utf8String);
begin
  __AssertProxyNotBusy('RegisterForDataChangeNotification');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'RegisterForDataChangeNotification');
  __Message.Write('aTableName', TypeInfo(Utf8String), aTableName, []);
  __DispatchAsyncRequest('RegisterForDataChangeNotification',__Message, false);
    __Message.UnsetAttributes(__TransportChannel);
end;

procedure TDataAbstractService_AsyncProxy.Invoke_UnregisterForDataChangeNotification(const aTableName: Utf8String);
begin
  __AssertProxyNotBusy('UnregisterForDataChangeNotification');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'UnregisterForDataChangeNotification');
  __Message.Write('aTableName', TypeInfo(Utf8String), aTableName, []);
  __DispatchAsyncRequest('UnregisterForDataChangeNotification',__Message, false);
    __Message.UnsetAttributes(__TransportChannel);
end;


{ CoSimpleLoginService }

class function CoSimpleLoginService_Async.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): ISimpleLoginService_Async;
begin
  result := TSimpleLoginService_AsyncProxy.Create(aMessage, aTransportChannel);
end;

{ TSimpleLoginService_AsyncProxy }

function TSimpleLoginService_AsyncProxy.__GetInterfaceName:string;
begin
  result := 'SimpleLoginService';
end;

procedure TSimpleLoginService_AsyncProxy.Invoke_Login(const aUserID: Utf8String; const aPassword: Utf8String);
begin
  __AssertProxyNotBusy('Login');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'Login');
  __Message.Write('aUserID', TypeInfo(Utf8String), aUserID, []);
  __Message.Write('aPassword', TypeInfo(Utf8String), aPassword, []);
  __DispatchAsyncRequest('Login',__Message);
    __Message.UnsetAttributes(__TransportChannel);
end;

function TSimpleLoginService_AsyncProxy.Retrieve_Login(out aUserInfo: UserInfo): Boolean;
var __response:TStream;
begin
  aUserInfo := nil;
  __response := __RetrieveAsyncResponse('Login');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(Boolean), Result, []);
  __Message.Read('aUserInfo', TypeInfo(UserInfo), aUserInfo, []);

  __response.Free();
end;


{ CoBaseLoginService }

class function CoBaseLoginService_Async.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IBaseLoginService_Async;
begin
  result := TBaseLoginService_AsyncProxy.Create(aMessage, aTransportChannel);
end;

{ TBaseLoginService_AsyncProxy }

function TBaseLoginService_AsyncProxy.__GetInterfaceName:string;
begin
  result := 'BaseLoginService';
end;

procedure TBaseLoginService_AsyncProxy.Invoke_Logout;
begin
  __AssertProxyNotBusy('Logout');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'Logout');
  __DispatchAsyncRequest('Logout',__Message, false);
end;


{ CoMultiDbLoginService }

class function CoMultiDbLoginService_Async.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IMultiDbLoginService_Async;
begin
  result := TMultiDbLoginService_AsyncProxy.Create(aMessage, aTransportChannel);
end;

{ TMultiDbLoginService_AsyncProxy }

function TMultiDbLoginService_AsyncProxy.__GetInterfaceName:string;
begin
  result := 'MultiDbLoginService';
end;

procedure TMultiDbLoginService_AsyncProxy.Invoke_Login(const aUserID: Utf8String; const aPassword: Utf8String; const aConnectionName: Utf8String);
begin
  __AssertProxyNotBusy('Login');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'Login');
  __Message.Write('aUserID', TypeInfo(Utf8String), aUserID, []);
  __Message.Write('aPassword', TypeInfo(Utf8String), aPassword, []);
  __Message.Write('aConnectionName', TypeInfo(Utf8String), aConnectionName, []);
  __DispatchAsyncRequest('Login',__Message);
    __Message.UnsetAttributes(__TransportChannel);
end;

function TMultiDbLoginService_AsyncProxy.Retrieve_Login(out aUserInfo: UserInfo): Boolean;
var __response:TStream;
begin
  aUserInfo := nil;
  __response := __RetrieveAsyncResponse('Login');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(Boolean), Result, []);
  __Message.Read('aUserInfo', TypeInfo(UserInfo), aUserInfo, []);

  __response.Free();
end;


{ CoMultiDbLoginServiceV5 }

class function CoMultiDbLoginServiceV5_Async.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IMultiDbLoginServiceV5_Async;
begin
  result := TMultiDbLoginServiceV5_AsyncProxy.Create(aMessage, aTransportChannel);
end;

{ TMultiDbLoginServiceV5_AsyncProxy }

function TMultiDbLoginServiceV5_AsyncProxy.__GetInterfaceName:string;
begin
  result := 'MultiDbLoginServiceV5';
end;

procedure TMultiDbLoginServiceV5_AsyncProxy.Invoke_GetConnectionNames;
begin
  __AssertProxyNotBusy('GetConnectionNames');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetConnectionNames');
  __DispatchAsyncRequest('GetConnectionNames',__Message);
end;

function TMultiDbLoginServiceV5_AsyncProxy.Retrieve_GetConnectionNames: StringArray;
var __response:TStream;
begin
  result := nil;
  __response := __RetrieveAsyncResponse('GetConnectionNames');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(StringArray), Result, []);

  __response.Free();
end;

procedure TMultiDbLoginServiceV5_AsyncProxy.Invoke_GetDefaultConnectionName;
begin
  __AssertProxyNotBusy('GetDefaultConnectionName');

  __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetDefaultConnectionName');
  __DispatchAsyncRequest('GetDefaultConnectionName',__Message);
end;

function TMultiDbLoginServiceV5_AsyncProxy.Retrieve_GetDefaultConnectionName: Utf8String;
var __response:TStream;
begin
  __response := __RetrieveAsyncResponse('GetDefaultConnectionName');
  __Message.ReadFromStream(__response);

  __Message.Read('Result', TypeInfo(Utf8String), Result, []);

  __response.Free();
end;


initialization
end.