      */
     public function get resultFormat():String
     {
-        return _resultFormat;
-    }
-
-    /**
-     *  @private
-     */
-    public function set resultFormat(value:String):void
-    {
-        switch (value)
-        {
-            case RESULT_FORMAT_OBJECT:
-            case RESULT_FORMAT_ARRAY:
-            case RESULT_FORMAT_XML:
-            case RESULT_FORMAT_E4X:
-            case RESULT_FORMAT_TEXT:
-            case RESULT_FORMAT_FLASHVARS:
-            {
-                break;
-            }
-
-            default:
-            {
-                var message:String = resourceManager.getString(
-                    "rpc", "invalidResultFormat",
-                    [ value, RESULT_FORMAT_OBJECT, RESULT_FORMAT_ARRAY,
-                      RESULT_FORMAT_XML, RESULT_FORMAT_E4X,
-                      RESULT_FORMAT_TEXT, RESULT_FORMAT_FLASHVARS ]);
-                throw new ArgumentError(message);
-            }
-        }
-        _resultFormat = value;
+        return operation.resultFormat;
+    }
+    public function set resultFormat(rf:String):void
+    {
+        operation.resultFormat = rf;
     }
 
     //----------------------------------
     //  rootURL
     //----------------------------------
-
-    /**
-     *  @private
-     */
-    mx_internal var _rootURL:String;
 
     /**
      *  The URL that the HTTPService object should use when computing relative URLs.

        if (parameters == null)
            parameters = request;

        var paramsToSend:Object;
        var token:AsyncToken;
        var fault:Fault;
        var faultEvent:FaultEvent;
        var msg:String;
        
         if (contentType == CONTENT_TYPE_XML)
         {
            if (!(parameters is XMLNode) && !(parameters is XML))
            {
                if (xmlEncode != null)
                {
                    var funcEncoded:Object = xmlEncode(parameters);
                    if (null == funcEncoded)
                    {
                        token = new AsyncToken(null);
                        msg = resourceManager.getString(
                            "rpc", "xmlEncodeReturnNull");
                        fault = new Fault(ERROR_ENCODING, msg);
                        faultEvent = FaultEvent.createEvent(fault, token);
                        new AsyncDispatcher(dispatchRpcEvent, [faultEvent], 10);
                        return token;
                    }
                    else if (!(funcEncoded is XMLNode))
                    {
                        token = new AsyncToken(null);
                        msg = resourceManager.getString(
                            "rpc", "xmlEncodeReturnNoXMLNode");
                        fault = new Fault(ERROR_ENCODING, msg);
                        faultEvent = FaultEvent.createEvent(fault, token);
                        new AsyncDispatcher(dispatchRpcEvent, [faultEvent], 10);
                        return token;
                    }
                    else
                    {
                        paramsToSend = XMLNode(funcEncoded).toString();
                    }
                }
                else
                {
                    var encoder:SimpleXMLEncoder = new SimpleXMLEncoder(null);                    
                    var xmlDoc:XMLDocument = new XMLDocument();
                    
                    //right now there is a wasted <encoded> wrapper tag
                    //call.appendChild(encoder.encodeValue(parameters));
                    var childNodes:Array = encoder.encodeValue(parameters, new QName(null, "encoded"), new XMLNode(1, "top")).childNodes.concat();                    
                    for (var i:int = 0; i < childNodes.length; ++i)
                        xmlDoc.appendChild(childNodes[i]);

                    paramsToSend = xmlDoc.toString();
                }
            }
            else
            {
                paramsToSend = XML(parameters).toXMLString();
            }
        }
        else if (contentType == CONTENT_TYPE_FORM)
        {
            paramsToSend = {};
            var val:Object;
            
            //get all dynamic and all concrete properties from the parameters object
            var classinfo:Object = ObjectUtil.getClassInfo(parameters);
            
            for each (var p:* in classinfo.properties)
            {
                val = parameters[p];
                if (val != null)
                {
                    if (val is Array)
                        paramsToSend[p] = val;
                    else
                        paramsToSend[p] = val.toString();
                }
            }
        }
        else
        {
            paramsToSend = parameters;
        }

        var message:HTTPRequestMessage = new HTTPRequestMessage();
        if (useProxy)
        {
            if (url && url != '')
            {
                message.url = URLUtil.getFullURL(rootURL, url);
            }

        }
        else
        {
            if (!url)
            {
                token = new AsyncToken(null);
                msg = resourceManager.getString(
                    "rpc", "urlNotSpecified");
                fault = new Fault(ERROR_URL_REQUIRED, msg);
                faultEvent = FaultEvent.createEvent(fault, token);
                new AsyncDispatcher(dispatchRpcEvent, [faultEvent], 10);
                return token;
            }

            if (!useProxy)
            {
                var dcs:ChannelSet = getDirectChannelSet();
                if (dcs != asyncRequest.channelSet)
                    asyncRequest.channelSet = dcs;
            }
            
            message.url = url;
        }

        message.contentType = contentType;
        message.method = method.toUpperCase();
        if (contentType == CONTENT_TYPE_XML && message.method == HTTPRequestMessage.GET_METHOD)
            message.method = HTTPRequestMessage.POST_METHOD;
        message.body = paramsToSend;
        message.httpHeaders = headers;
        return invoke(message);
    }
    
    /**

     */
    public function get rootURL():String
    {
        return operation.rootURL;
    }
    public function set rootURL(ru:String):void
    {
        operation.rootURL = ru;
    }

    //----------------------------------
    //  showBusyCursor
    //----------------------------------

    [Inspectable(defaultValue="false", category="General")]
    /**
    * If <code>true</code>, a busy cursor is displayed while a service is executing. The default
    * value is <code>false</code>.
    */
    public function get showBusyCursor():Boolean
    {
        return operation.showBusyCursor;
    }

    public function set showBusyCursor(sbc:Boolean):void
    {
        operation.showBusyCursor = sbc;
    }

    //----------------------------------
    //  serializationFilter 
    //----------------------------------

    /**
     * Provides an adapter which controls the process of converting the HTTP response body into 
     * ActionScript objects and/or turning the parameters or body into the contentType, URL, and
     * and post body of the HTTP request.  This can also be set indirectly by setting the 
     * resultFormat by registering a SerializationFilter using the static method:
     * SerializationFilter.registerFilterForResultFormat("formatName", filter)
     */
    public function get serializationFilter():SerializationFilter
    {
        return operation.serializationFilter;
    }
    public function set serializationFilter(s:SerializationFilter):void
    {
        operation.serializationFilter = s;
    }
    
    [Inspectable(defaultValue="undefined", category="General")]
    /**
     *  Location of the service. If you specify the <code>url</code> and a non-default destination,
