<?php 
/*
    This file has been automatically created by the RemObjects SDK. Any 
    changes in this file will be lost when the file is recreated.

    This file depends on the PHP xmlrpc library from:
    http://phpxmlrpc.sourceforge.net/
*/

require_once("xmlrpc.inc");

class LicenseServerLIBHelpers {
    static function RaiseException($message)
    {
        $i = strpos(":", $message);
        if ($i <= 0) {
            throw new Exception($message);
        } else {
            $class = substr($message, 0, $i);
            $submsg = substring($message, $i+1);
            switch($class)
            {
                default: throw new Exception($message);
            }
        }
    }
    // Scalar from array
    static function FromArray($data, $subtype)
    {
        $items = array();
        for ($i = 0; $i < sizeof($data); $i++) $items[$i] = new xmlrpcval($data[$i], $subtype);
        $res = new xmlrpcval();
        $res->addArray($items);;
        return $res;
    }
    // Scalar to array
    static function ToArray($data)
    {
        $items = array();
        for ($i = 0; $i < $data->arraysize(); $i++) $items[$i] = $data->arraymem($i)->scalarval();
        return $items;
    }
}

class DataParameter {
    public $Name; // Utf8String
    public $Value; // Variant

    function DataParameter() {}
    static function FromXmlRpcVal($n) {
        $res = new DataParameter();
        $res->Name = Utf8String::FromXmlRpcVal($n->structmem("Name"));
        $res->Value = $n->structmem("Value")->scalarval();
        return $res;
    }
    static function ToXmlRpcVal($data) {
        $res = new xmlrpcval();
        $arr = array();
        $arr["Name"] = Utf8String::ToXmlRpcVal($data->Name, "string");
        $arr["Value"] = new xmlrpcval($data->Value, "variant");
        $res->addStruct($arr);
        return $res;
    }
    static function FromArray($data)
    {
        $items = array();
        for ($i = 0; $i < sizeof($data); $i++) {
            $items[$i] = DataParameter::ToXmlRpcVal($data[$i]);
        }
        $res = new xmlrpcval();
        $res->addArray($items);;
        return $res;
    }
    static function ToArray($data)
    {
        $items = array();
        for ($i = 0; $i < $data->arraysize(); $i++) $items[$i] = DataParameter::FromXmlRpcVal($data->arraymem($i));
        return $items;
    }
}

class TableRequestInfo {
    public $UserFilter; // Utf8String
    public $IncludeSchema; // Boolean
    public $MaxRecords; // Integer
    public $Parameters; // DataParameterArray

    function TableRequestInfo() {}
    static function FromXmlRpcVal($n) {
        $res = new TableRequestInfo();
        $res->UserFilter = Utf8String::FromXmlRpcVal($n->structmem("UserFilter"));
        $res->IncludeSchema = $n->structmem("IncludeSchema")->scalarval();
        $res->MaxRecords = $n->structmem("MaxRecords")->scalarval();
        $res->Parameters = DataParameter::ToArray($n->structmem("Parameters"));
        return $res;
    }
    static function ToXmlRpcVal($data) {
        $res = new xmlrpcval();
        $arr = array();
        $arr["UserFilter"] = Utf8String::ToXmlRpcVal($data->UserFilter, "string");
        $arr["IncludeSchema"] = new xmlrpcval($data->IncludeSchema, "boolean");
        $arr["MaxRecords"] = new xmlrpcval($data->MaxRecords, "int");
        $arr["Parameters"] = DataParameter::FromArray($data->Parameters, "string");
        $res->addStruct($arr);
        return $res;
    }
    static function FromArray($data)
    {
        $items = array();
        for ($i = 0; $i < sizeof($data); $i++) {
            $items[$i] = TableRequestInfo::ToXmlRpcVal($data[$i]);
        }
        $res = new xmlrpcval();
        $res->addArray($items);;
        return $res;
    }
    static function ToArray($data)
    {
        $items = array();
        for ($i = 0; $i < $data->arraysize(); $i++) $items[$i] = TableRequestInfo::FromXmlRpcVal($data->arraymem($i));
        return $items;
    }
}

class UserInfo {
    public $SessionID; // Utf8String
    public $UserID; // Utf8String
    public $Privileges; // StringArray
    public $Attributes; // VariantArray
    public $UserData; // Binary

    function UserInfo() {}
    static function FromXmlRpcVal($n) {
        $res = new UserInfo();
        $res->SessionID = Utf8String::FromXmlRpcVal($n->structmem("SessionID"));
        $res->UserID = Utf8String::FromXmlRpcVal($n->structmem("UserID"));
        $res->Privileges = Utf8String::ToArray($n->structmem("Privileges"));
        $res->Attributes = LicenseServerLIBHelpers::ToArray($n->structmem("Attributes"));
        $res->UserData = $n->structmem("UserData")->scalarval();
        return $res;
    }
    static function ToXmlRpcVal($data) {
        $res = new xmlrpcval();
        $arr = array();
        $arr["SessionID"] = Utf8String::ToXmlRpcVal($data->SessionID, "string");
        $arr["UserID"] = Utf8String::ToXmlRpcVal($data->UserID, "string");
        $arr["Privileges"] = Utf8String::FromArray($data->Privileges, "string");
        $arr["Attributes"] = LicenseServerLIBHelpers::FromArray($data->Attributes, "string");
        $arr["UserData"] = new xmlrpcval($data->UserData, "base64");
        $res->addStruct($arr);
        return $res;
    }
    static function FromArray($data)
    {
        $items = array();
        for ($i = 0; $i < sizeof($data); $i++) {
            $items[$i] = UserInfo::ToXmlRpcVal($data[$i]);
        }
        $res = new xmlrpcval();
        $res->addArray($items);;
        return $res;
    }
    static function ToArray($data)
    {
        $items = array();
        for ($i = 0; $i < $data->arraysize(); $i++) $items[$i] = UserInfo::FromXmlRpcVal($data->arraymem($i));
        return $items;
    }
}

class TableRequestInfoV5 {
    public $WhereClause; // Xml
    public $DynamicSelectFieldNames; // StringArray
    public $Sorting; // ColumnSorting

    function TableRequestInfoV5() {}
    static function FromXmlRpcVal($n) {
        $res = new TableRequestInfoV5();
        $res->WhereClause = Xml::FromXmlRpcVal($n->structmem("WhereClause"));
        $res->DynamicSelectFieldNames = Utf8String::ToArray($n->structmem("DynamicSelectFieldNames"));
        $res->Sorting = ColumnSorting::FromXmlRpcVal($n->structmem("Sorting"));
        return $res;
    }
    static function ToXmlRpcVal($data) {
        $res = new xmlrpcval();
        $arr = array();
        $arr["WhereClause"] = Xml::ToXmlRpcVal($data->WhereClause, "string");
        $arr["DynamicSelectFieldNames"] = Utf8String::FromArray($data->DynamicSelectFieldNames, "string");
        $arr["Sorting"] = ColumnSorting::ToXmlRpcVal($data->Sorting, "string");
        $res->addStruct($arr);
        return $res;
    }
    static function FromArray($data)
    {
        $items = array();
        for ($i = 0; $i < sizeof($data); $i++) {
            $items[$i] = TableRequestInfoV5::ToXmlRpcVal($data[$i]);
        }
        $res = new xmlrpcval();
        $res->addArray($items);;
        return $res;
    }
    static function ToArray($data)
    {
        $items = array();
        for ($i = 0; $i < $data->arraysize(); $i++) $items[$i] = TableRequestInfoV5::FromXmlRpcVal($data->arraymem($i));
        return $items;
    }
}

class ColumnSorting {
    public $FieldName; // Utf8String
    public $SortDirection; // ColumnSortDirection

    function ColumnSorting() {}
    static function FromXmlRpcVal($n) {
        $res = new ColumnSorting();
        $res->FieldName = Utf8String::FromXmlRpcVal($n->structmem("FieldName"));
        $res->SortDirection = $n->structmem("SortDirection")->scalarval();
        return $res;
    }
    static function ToXmlRpcVal($data) {
        $res = new xmlrpcval();
        $arr = array();
        $arr["FieldName"] = Utf8String::ToXmlRpcVal($data->FieldName, "string");
        $arr["SortDirection"] = new xmlrpcval($data->SortDirection, "int");
        $res->addStruct($arr);
        return $res;
    }
    static function FromArray($data)
    {
        $items = array();
        for ($i = 0; $i < sizeof($data); $i++) {
            $items[$i] = ColumnSorting::ToXmlRpcVal($data[$i]);
        }
        $res = new xmlrpcval();
        $res->addArray($items);;
        return $res;
    }
    static function ToArray($data)
    {
        $items = array();
        for ($i = 0; $i < $data->arraysize(); $i++) $items[$i] = ColumnSorting::FromXmlRpcVal($data->arraymem($i));
        return $items;
    }
}

class TableRequestInfoV6 {
    public $Sql; // Widestring

    function TableRequestInfoV6() {}
    static function FromXmlRpcVal($n) {
        $res = new TableRequestInfoV6();
        $res->Sql = $n->structmem("Sql")->scalarval();
        return $res;
    }
    static function ToXmlRpcVal($data) {
        $res = new xmlrpcval();
        $arr = array();
        $arr["Sql"] = new xmlrpcval($data->Sql, "string");
        $res->addStruct($arr);
        return $res;
    }
    static function FromArray($data)
    {
        $items = array();
        for ($i = 0; $i < sizeof($data); $i++) {
            $items[$i] = TableRequestInfoV6::ToXmlRpcVal($data[$i]);
        }
        $res = new xmlrpcval();
        $res->addArray($items);;
        return $res;
    }
    static function ToArray($data)
    {
        $items = array();
        for ($i = 0; $i < $data->arraysize(); $i++) $items[$i] = TableRequestInfoV6::FromXmlRpcVal($data->arraymem($i));
        return $items;
    }
}

class DataAbstractService {
    function DataAbstractService($path, $server='', $port='', $method='') {
        $this->___server = new xmlrpc_client($path, $server, $port, $method);
    }

    function GetXmlRpcClient() {
        return $this->___server;
    }
    // GetSchema(aFilter: Utf8String) {
    function GetSchema($aFilter) {
        $___msg = new xmlrpcmsg("DataAbstractService.GetSchema");
        $___msg->addParam(Utf8String::ToXmlRpcVal($aFilter));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return Utf8String::FromXmlRpcVal($___res->value());
    }
    // GetData(aTableNameArray: StringArray, aTableRequestInfoArray: TableRequestInfoArray) {
    function GetData($aTableNameArray, $aTableRequestInfoArray) {
        $___msg = new xmlrpcmsg("DataAbstractService.GetData");
        $___msg->addParam(Utf8String::FromArray($aTableNameArray));
        $___msg->addParam(TableRequestInfo::FromArray($aTableRequestInfoArray));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // UpdateData(aDelta: Binary) {
    function UpdateData($aDelta) {
        $___msg = new xmlrpcmsg("DataAbstractService.UpdateData");
        $___msg->addParam(new xmlrpcval($aDelta, "base64"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // ExecuteCommand(aCommandName: Utf8String, aParameterArray: DataParameterArray) {
    function ExecuteCommand($aCommandName, $aParameterArray) {
        $___msg = new xmlrpcmsg("DataAbstractService.ExecuteCommand");
        $___msg->addParam(Utf8String::ToXmlRpcVal($aCommandName));
        $___msg->addParam(DataParameter::FromArray($aParameterArray));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // ExecuteCommandEx(aCommandName: Utf8String, aInputParameters: DataParameterArray, aOutputParameters: DataParameterArray) {
    function ExecuteCommandEx($aCommandName, $aInputParameters, $aOutputParameters) {
        $___msg = new xmlrpcmsg("DataAbstractService.ExecuteCommandEx");
        $___msg->addParam(Utf8String::ToXmlRpcVal($aCommandName));
        $___msg->addParam(DataParameter::FromArray($aInputParameters));
        $___msg->addParam(DataParameter::FromArray($aOutputParameters));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // GetTableSchema(aTableNameArray: StringArray) {
    function GetTableSchema($aTableNameArray) {
        $___msg = new xmlrpcmsg("DataAbstractService.GetTableSchema");
        $___msg->addParam(Utf8String::FromArray($aTableNameArray));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return Utf8String::FromXmlRpcVal($___res->value());
    }
    // GetCommandSchema(aCommandNameArray: StringArray) {
    function GetCommandSchema($aCommandNameArray) {
        $___msg = new xmlrpcmsg("DataAbstractService.GetCommandSchema");
        $___msg->addParam(Utf8String::FromArray($aCommandNameArray));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return Utf8String::FromXmlRpcVal($___res->value());
    }
    // SQLGetData(aSQLText: Utf8String, aIncludeSchema: Boolean, aMaxRecords: Integer) {
    function SQLGetData($aSQLText, $aIncludeSchema, $aMaxRecords) {
        $___msg = new xmlrpcmsg("DataAbstractService.SQLGetData");
        $___msg->addParam(Utf8String::ToXmlRpcVal($aSQLText));
        $___msg->addParam(new xmlrpcval($aIncludeSchema, "boolean"));
        $___msg->addParam(new xmlrpcval($aMaxRecords, "int"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // SQLGetDataEx(aSQLText: Utf8String, aIncludeSchema: Boolean, aMaxRecords: Integer, aDynamicWhereXML: Widestring) {
    function SQLGetDataEx($aSQLText, $aIncludeSchema, $aMaxRecords, $aDynamicWhereXML) {
        $___msg = new xmlrpcmsg("DataAbstractService.SQLGetDataEx");
        $___msg->addParam(Utf8String::ToXmlRpcVal($aSQLText));
        $___msg->addParam(new xmlrpcval($aIncludeSchema, "boolean"));
        $___msg->addParam(new xmlrpcval($aMaxRecords, "int"));
        $___msg->addParam(new xmlrpcval($aDynamicWhereXML, "string"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // SQLExecuteCommand(aSQLText: Utf8String) {
    function SQLExecuteCommand($aSQLText) {
        $___msg = new xmlrpcmsg("DataAbstractService.SQLExecuteCommand");
        $___msg->addParam(Utf8String::ToXmlRpcVal($aSQLText));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // SQLExecuteCommandEx(aSQLText: Utf8String, aDynamicWhereXML: Widestring) {
    function SQLExecuteCommandEx($aSQLText, $aDynamicWhereXML) {
        $___msg = new xmlrpcmsg("DataAbstractService.SQLExecuteCommandEx");
        $___msg->addParam(Utf8String::ToXmlRpcVal($aSQLText));
        $___msg->addParam(new xmlrpcval($aDynamicWhereXML, "string"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // GetDatasetScripts(DatasetNames: Utf8String) {
    function GetDatasetScripts($DatasetNames) {
        $___msg = new xmlrpcmsg("DataAbstractService.GetDatasetScripts");
        $___msg->addParam(Utf8String::ToXmlRpcVal($DatasetNames));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return Utf8String::FromXmlRpcVal($___res->value());
    }
    // RegisterForDataChangeNotification(aTableName: Utf8String) {
    function RegisterForDataChangeNotification($aTableName) {
        $___msg = new xmlrpcmsg("DataAbstractService.RegisterForDataChangeNotification");
        $___msg->addParam(Utf8String::ToXmlRpcVal($aTableName));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
    }
    // UnregisterForDataChangeNotification(aTableName: Utf8String) {
    function UnregisterForDataChangeNotification($aTableName) {
        $___msg = new xmlrpcmsg("DataAbstractService.UnregisterForDataChangeNotification");
        $___msg->addParam(Utf8String::ToXmlRpcVal($aTableName));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
    }
}
class SimpleLoginService {
    function SimpleLoginService($path, $server='', $port='', $method='') {
        $this->___server = new xmlrpc_client($path, $server, $port, $method);
    }

    function GetXmlRpcClient() {
        return $this->___server;
    }
    // Login(aUserID: Utf8String, aPassword: Utf8String, aUserInfo: UserInfo) {
    function Login($aUserID, $aPassword, $aUserInfo) {
        $___msg = new xmlrpcmsg("SimpleLoginService.Login");
        $___msg->addParam(Utf8String::ToXmlRpcVal($aUserID));
        $___msg->addParam(Utf8String::ToXmlRpcVal($aPassword));
        $___msg->addParam(UserInfo::ToXmlRpcVal($aUserInfo));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
}
class BaseLoginService {
    function BaseLoginService($path, $server='', $port='', $method='') {
        $this->___server = new xmlrpc_client($path, $server, $port, $method);
    }

    function GetXmlRpcClient() {
        return $this->___server;
    }
    // Logout() {
    function Logout() {
        $___msg = new xmlrpcmsg("BaseLoginService.Logout");
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
    }
}
class MultiDbLoginService {
    function MultiDbLoginService($path, $server='', $port='', $method='') {
        $this->___server = new xmlrpc_client($path, $server, $port, $method);
    }

    function GetXmlRpcClient() {
        return $this->___server;
    }
    // Login(aUserID: Utf8String, aPassword: Utf8String, aConnectionName: Utf8String, aUserInfo: UserInfo) {
    function Login($aUserID, $aPassword, $aConnectionName, $aUserInfo) {
        $___msg = new xmlrpcmsg("MultiDbLoginService.Login");
        $___msg->addParam(Utf8String::ToXmlRpcVal($aUserID));
        $___msg->addParam(Utf8String::ToXmlRpcVal($aPassword));
        $___msg->addParam(Utf8String::ToXmlRpcVal($aConnectionName));
        $___msg->addParam(UserInfo::ToXmlRpcVal($aUserInfo));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
}
class MultiDbLoginServiceV5 {
    function MultiDbLoginServiceV5($path, $server='', $port='', $method='') {
        $this->___server = new xmlrpc_client($path, $server, $port, $method);
    }

    function GetXmlRpcClient() {
        return $this->___server;
    }
    // GetConnectionNames() {
    function GetConnectionNames() {
        $___msg = new xmlrpcmsg("MultiDbLoginServiceV5.GetConnectionNames");
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return Utf8String::ToArray($___res->value());
    }
    // GetDefaultConnectionName() {
    function GetDefaultConnectionName() {
        $___msg = new xmlrpcmsg("MultiDbLoginServiceV5.GetDefaultConnectionName");
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return Utf8String::FromXmlRpcVal($___res->value());
    }
}
class ServiceLicenseManager {
    function ServiceLicenseManager($path, $server='', $port='', $method='') {
        $this->___server = new xmlrpc_client($path, $server, $port, $method);
    }

    function GetXmlRpcClient() {
        return $this->___server;
    }
    // Login(Apelido: AnsiString, Senha: AnsiString) {
    function Login($Apelido, $Senha) {
        $___msg = new xmlrpcmsg("ServiceLicenseManager.Login");
        $___msg->addParam(new xmlrpcval($Apelido, "string"));
        $___msg->addParam(new xmlrpcval($Senha, "string"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // Logout(Apelido: AnsiString) {
    function Logout($Apelido) {
        $___msg = new xmlrpcmsg("ServiceLicenseManager.Logout");
        $___msg->addParam(new xmlrpcval($Apelido, "string"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
}
class ValidadorLicenseManager {
    function ValidadorLicenseManager($path, $server='', $port='', $method='') {
        $this->___server = new xmlrpc_client($path, $server, $port, $method);
    }

    function GetXmlRpcClient() {
        return $this->___server;
    }
    // Homologar(CPUID: AnsiString, VendaID: AnsiString) {
    function Homologar($CPUID, $VendaID) {
        $___msg = new xmlrpcmsg("ValidadorLicenseManager.Homologar");
        $___msg->addParam(new xmlrpcval($CPUID, "string"));
        $___msg->addParam(new xmlrpcval($VendaID, "string"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // CarregarLicencas(AES: AnsiString) {
    function CarregarLicencas($AES) {
        $___msg = new xmlrpcmsg("ValidadorLicenseManager.CarregarLicencas");
        $___msg->addParam(new xmlrpcval($AES, "string"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // Validar(AES: AnsiString, VERSAO: AnsiString) {
    function Validar($AES, $VERSAO) {
        $___msg = new xmlrpcmsg("ValidadorLicenseManager.Validar");
        $___msg->addParam(new xmlrpcval($AES, "string"));
        $___msg->addParam(new xmlrpcval($VERSAO, "string"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // LicencasExcedidas(AES: AnsiString, XML: AnsiString) {
    function LicencasExcedidas($AES, $XML) {
        $___msg = new xmlrpcmsg("ValidadorLicenseManager.LicencasExcedidas");
        $___msg->addParam(new xmlrpcval($AES, "string"));
        $___msg->addParam(new xmlrpcval($XML, "string"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // ExcessosDoDia(cod_vendas: Integer, cod_modulos: Integer, data: AnsiString) {
    function ExcessosDoDia($cod_vendas, $cod_modulos, $data) {
        $___msg = new xmlrpcmsg("ValidadorLicenseManager.ExcessosDoDia");
        $___msg->addParam(new xmlrpcval($cod_vendas, "int"));
        $___msg->addParam(new xmlrpcval($cod_modulos, "int"));
        $___msg->addParam(new xmlrpcval($data, "string"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // TornarIntolerante(AES: AnsiString) {
    function TornarIntolerante($AES) {
        $___msg = new xmlrpcmsg("ValidadorLicenseManager.TornarIntolerante");
        $___msg->addParam(new xmlrpcval($AES, "string"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
    }
    // CTToken(NomeArquivo: AnsiString, Arquivo: Binary) {
    function CTToken($NomeArquivo, $Arquivo) {
        $___msg = new xmlrpcmsg("ValidadorLicenseManager.CTToken");
        $___msg->addParam(new xmlrpcval($NomeArquivo, "string"));
        $___msg->addParam(new xmlrpcval($Arquivo, "base64"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
    // CarregarLicencasPorCodigoVenda(CodigoVenda: AnsiString) {
    function CarregarLicencasPorCodigoVenda($CodigoVenda) {
        $___msg = new xmlrpcmsg("ValidadorLicenseManager.CarregarLicencasPorCodigoVenda");
        $___msg->addParam(new xmlrpcval($CodigoVenda, "string"));
        $___res = $this->___server->send($___msg);
        if ($___res->faultCode()) LicenseServerLIBHelpers::RaiseException($___res->faultString());
        return $___res->value()->scalarval();
    }
}