<script src="http://yui.yahooapis.com/3.0.0/build/yui/yui-min.js"></script>

// Create new YUI instance, and populate it with the required modules
YUI().use('io', function(Y) {
 
    // IO available, and ready for use.
 
});

// Create a YUI instance using io-base module.
YUI().use("io-base", function(Y) {
    var uri = "get.php?foo=bar";
 
    // Define a function to handle the response data.
    function complete(id, o, args) {
        var id = id; // Transaction ID.
        var data = o.responseText; // Response data.
        var args = args[1]; // 'ipsum'.
    };
 
    // Subscribe to event "io:complete", and pass an array
    // as an argument to the event handler "complete", since
    // "complete" is global.   At this point in the transaction
    // lifecycle, success or failure is not yet known.
    Y.on('io:complete', complete, this, ['lorem', 'ipsum']);
 
    // Make an HTTP request to 'get.php'.
    // NOTE: This transaction does not use a configuration object.
    var request = Y.io(uri);
});
 

/*
 * This is an example configuration object with all properties defined.
 *
 * method: This transaction will use HTTP POST.
 * data: "user=yahoo" is the POST data.
 * headers: Object of HTTP request headers for this transaction.  The
 *          first header defines "Content-Type" and the second is a
 *          custom header.
 * on: Object of defined event handlers for "start", "complete",
 *     and "end".  These handlers are methods of an object
 *     named "Dispatch".
 * context: Event handlers will execute in the propert object context,
 *          so usage 'this' will reference Dispatch.
 * form: Object specifying the HTML form to be serialized into a key-value
 *       string and sent as data; and, informing io to include disabled
 *       HTML form fields as part of the data.  If input type of "file"
 *       is present, setting the upload property to "true" will create an
 *       alternate transport, to submit the HTML form with the
 *       selected files.
 * xdr: Instructs io to use the defined transport, in this case Flash,
 *      to make a cross-domain request for this transaction.
 * arguments: Object of data, passed as an argument to the event
 *            handlers.
 */
var cfg = {
	method: 'POST',
	data: 'user=yahoo',
	headers: {
		'Content-Type': 'application/json',
		'X-TRANSPORT-TYPE': 'Flash'
	},
	on: {
		start: Dispatch.start,
		complete: Dispatch.complete,
		end: Dispatch.end
		}
	},
	context: Dispatch,
	form: {
		id: formObject,
		useDisabled: true,
		upload: true
	},
	xdr: {
		use: 'flash',
		dataType: 'xml'
	},
	arguments: {
		start: 'foo',
		complete: 'bar',
		end: 'baz'
	}
};
 

// Create a YUI instance using io module.
YUI().use("io-base", function(Y) {
	/*
	 * Create a function as the event handler for the event "io:complete".
	 *
	 * The function will receive the following arguments:
	 * - The ID of the transaction
	 * - Object containing the response data.
	 * - Argument one defined when subscribing to the event(e.g., "foo").
	 * - Argument two defined when subscribing to the event(e.g., "bar").
	 */
	function onComplete(transactionId, responseObject, arg1, arg2) {
		/*
		 * The argument 'responseObject' is the response object.  Its
		 * properties are:
		 * - status
		 * - statusText
		 * - getResponseHeader(headerName)
		 * - getAllResponseHeaders
		 * - responseText
		 * - responseXML
		 *
		 * NOTE: In an XDR transaction, only the responseText or the responseXML property is defined.
		 */
	};
 
	/*
	 * Subscribe to the event "io:complete", using Y.on.
	 *
	 * - 'io:complete' : Subscribe to this io event.
	 * - onComplete : The event handler to be subscribed to 'io:complete'.
	 * - Y : The execution context of the event handler, in this case, the YUI sandbox.
	 *          since the doComplete is defined as a global function.
	 * - 'foo' : The first argument received by the event handler.
	 * - 'bar' : The second argument received by the event handler.
	 *           Additional arguments can be defined, as desired.
	 */
	Y.on('io:complete', onComplete, this, "foo", "bar");
 
	// Starts the transaction.
	var request = Y.io(uri);
});
 

<?xml version="1.0"?>
<!DOCTYPE cross-domain-policy SYSTEM
"http://www.adobe.com/xml/dtds/cross-domain-policy.dtd">
<cross-domain-policy>
	<allow-access-from domain="*"/>
	<allow-http-request-headers-from domain="*.yahoo.com" headers="*"/>
</cross-domain-policy>
 

// Create a YUI instance using the io cross-domain submodule
YUI().use("io-xdr", function(Y) {
	// Create a configuration object with the src property defined,
	// src: The path to the Flash file, relative to the HTML.
	var xdrCfg = {
		src:'io.swf'
	};
 
	// Initialize the define transport
	Y.io.transport(xdrCfg);
 
	// Define the configurations to be used for each transaciton..
	var cfg = {
	  use: 'flash', // Instruct io to use the flash XDR transport.
	  data: 'foo=bar&baz=boo' // Key-value string of data.
	  timeout: 3000, // Abort the transaction, if it is still pending, after 3000ms.
	  // An object passed, as an argument, to the event handlers.
	  arguments: {
		start: 'foo',
		complete: 'bar',
		end: 'baz'
	  }
	};
 
	/*
	 * GlobalEventHandler is an example object that encapsulates
	 * event handlers for "io:start", "io:complete", and "io:end".
	 *
	 * start( ) // Event handler for "io:start"
	 * success( ) // Event handler for "io:complete".
	 * end( ) // Event handler for "io:end".
	 */
	var GlobalEventHandler = {
	  start: function(id, args) {
		var args = args.start // 'foo'
	  },
	  success: function(id, o, args) {
		var args = args.complete; // 'bar'
		var data = o.responseText;
		var xml = o.responseXML;
	  },
	  end: function(id, args) {
		var args = args.end // args = 'baz'
	  }
	};
 
	// Subscribe GlobalEventHandler.start to event "io:start".
	Y.on('io:start', GlobalEventHandler.start, this);
	// Subscribe GlobalEventHandler.complete to event "io:complete".
	Y.on('io:success', GlobalEventHandler.complete, this);
	// Subscribe GlobalEventHandler to event "io:end".
	Y.on('io:end', GlobalEventHandler.end, this);
 
	// Start the transaction
	var request = Y.io(uri, cfg);
});
 

// Create a YUI instance using the io-form sub-module.
YUI().use("io-form", function(Y) {
	// Create a configuration object for the file upload transaction.
	// The form configuration should include two defined properties:
	// id: This can be the ID or an object reference to the HTML form.
	// useDisabled: Set this property to "true" to include disabled
	//              HTML form fields, as part of the data.  By
	//              default, disabled fields are excluded from the
	//              serialization.
	// The HTML form data are sent as a UTF-8 encoded key-value string.
	var cfg = {
		method: 'POST',
		form: {
			id: formObject,
			useDisabled: true
		}
	};
 
	// Define a function to handle the response data.
	function complete(id, o, args) {
	  var id = id; // Transaction ID.
	  var data = o.responseText; // Response data.
	  var args = args[1]; // 'ipsum'.
	};
 
	// Subscribe to event "io:complete", and pass an array
	// as an argument to the event handler "complete".
	Y.on('io:complete', complete, this, { 'foo':'bar' });
 
	// Start the transaction.
	var request = Y.io(uri, cfg);
});
 

/*
 * This example demonstrates how to configure io to upload files
 * from an HTML form.  This example uses the global events:
 * "io:start" and "io:complete" to handle the transaction and
 * response.  Transaction events can be defined and fired, as well,
 * in the configuration object; but, they are not used in this
 * example.
 */
// Create a YUI instance using the io-upload-iframe sub-module.
YUI().use("io-upload-iframe", function(Y) {
	// Create a configuration object for the file upload transaction.
	// The form configuration should include two defined properties:
	// id: This can be the ID or an object reference to the HTML form
	//     containing the input type="file" elements.
	// upload: Set this property to "true" to indicate this is a file
	//         upload transaction.
	var cfg = {
		method: 'POST',
		form: {
			id: formObject,
			upload: true
		}
	};
 
	// Define a function to handle the start of a transaction
	function start(id, args) {
	  var id = id; // Transaction ID.
	  var args = args.foo; // 'bar'
	}
 
	// Define a function to handle the response data.
	function complete(id, o, args) {
	  var id = id; // Transaction ID.
	  var data = o.responseText; // Response data.
	  var args = args[1]; // 'ipsum'.
	};
 
	// Subscribe to event "io:start", and pass an object
	// as an argument to the event handler "start".
	Y.on('io:start', start, Y, { 'foo':'bar' });
 
	// Subscribe to event "io:complete", and pass an array
	// as an argument to the event handler "complete".
	Y.on('io:complete', complete, Y, ['lorem', 'ipsum']);
 
	// Start the transaction.
	var request = Y.io(uri, cfg);
});
 

YUI().use("io-base", function(Y) {
 
	// Set a new default HTTP header.
	Y.io.header('Content-Type', 'application/json');
 
	// To remove an existing header, use the same method, but omit the value.
	Y.io.header('Content-Type');
});
 

// Create a YUI instance using the io queue sub-module.
YUI().use("io-queue", function(Y) {
 
	// Stop the queue so transactions can be stored.
	Y.io.queue.stop();
 
	// Send four transactions into the queue for storage.
	var task0 = Y.io.queue(uri);
	var task1 = Y.io.queue(uri);
	var task2 = Y.io.queue(uri);
	var task3 = Y.io.queue(uri);
 
	// Promote task2 to the top of the queue.
	Y.io.queue.promote(task2);
 
	// Purge task3 from the queue.
	Y.io.queue.purge(task3);
 
	// Re-start the queue.
	// Transactions are sent in the following order: task2, task0, task 1.
	// Transaction callbacks, if provided, will be processed in the same
	// sequence: task2, task0, task1, regardless of actual response order.
	//
	Y.io.queue.start();
});