text: define("dojox/data/PersevereStore", ["dojo", "dojox", "require", "dojox/data/JsonQueryRestStore", "dojox/rpc/Client", "dojo/_base/url"], function(dojo, dojox, require) {
  
  // PersevereStore is an extension of JsonRestStore to handle Persevere's special features
  
  dojox.json.ref.serializeFunctions = true; // Persevere supports persisted functions
  
  var PersevereStore = dojo.declare("dojox.data.PersevereStore", dojox.data.JsonQueryRestStore, {
  	useFullIdInQueries: true, // in JSONQuerys use the full id
  	jsonQueryPagination: false // use the Range headers instead
  });
  
  PersevereStore.getStores = function(/*String?*/ path,/*Boolean?*/ sync){
  	// summary:
  	//		Creates Dojo data stores for all the table/classes on a Persevere server
  	// path:
  	//		URL of the Persevere server's root, this normally just "/"
  	//		which is the default value if the target is not provided
  	// sync:
  	//		Indicates that the operation should happen synchronously.
  	// returns:
  	//		A map/object of datastores will be returned if it is performed asynchronously,
  	//		otherwise it will return a Deferred object that will provide the map/object.
  	//		The name of each property is a the name of a store,
  	//		and the value is the actual data store object.
  	path = (path && (path.match(/\/$/) ? path : (path + '/'))) || '/';
  	if(path.match(/^\w*:\/\//)){
  		// if it is cross-domain, we will use window.name for communication
  		require("dojox/io/xhrScriptPlugin");
  		dojox.io.xhrScriptPlugin(path, "callback", dojox.io.xhrPlugins.fullHttpAdapter);
  	}
  	var plainXhr = dojo.xhr;
  	dojo.xhr = function(method,args){
  		(args.headers = args.headers || {})['Server-Methods'] = "false";
  		return plainXhr.apply(dojo,arguments);
  	};
  	var rootService= dojox.rpc.Rest(path,true);
  	dojox.rpc._sync = sync;
  	var dfd = rootService("Class/");//dojo.xhrGet({url: target, sync:!callback, handleAs:'json'});
  	var results;
  	var stores = {};
  	var callId = 0;
  	dfd.addCallback(function(schemas){
  		dojox.json.ref.resolveJson(schemas, {
  			index: dojox.rpc.Rest._index,
  			idPrefix: "/Class/",
  			assignAbsoluteIds: true
  		});
  		function setupHierarchy(schema){
  			if(schema['extends'] && schema['extends'].prototype){
  				if(!schema.prototype || !schema.prototype.isPrototypeOf(schema['extends'].prototype)){
  					setupHierarchy(schema['extends']);
  					dojox.rpc.Rest._index[schema.prototype.__id] = schema.prototype = dojo.mixin(dojo.delegate(schema['extends'].prototype), schema.prototype);
  				}
  			}
  		}
  		function setupMethods(methodsDefinitions, methodsTarget){
  			if(methodsDefinitions && methodsTarget){
  				for(var j in methodsDefinitions){
  					var methodDef = methodsDefinitions[j];
  					// if any method definitions indicate that the method should run on the server, than add
  					// it to the prototype as a JSON-RPC method
  					if(methodDef.runAt != "client" && !methodsTarget[j]){
  						methodsTarget[j] = (function(methodName){
  							return function(){
  								// execute a JSON-RPC call
  								var deferred = dojo.rawXhrPost({
  									url: this.__id,
  									// the JSON-RPC call
  									postData: dojox.json.ref.toJson({
  										method: methodName,
  										id: callId++,
  										params: dojo._toArray(arguments)
  									}),
  									handleAs: "json"
  								});
  								deferred.addCallback(function(response){
  									// handle the response
  									return response.error ?
  										new Error(response.error) :
  										response.result;
  								});
  								return deferred;
  							}
  						})(j);
  					}
  				}
  			}
  		}
  		for(var i in schemas){
  			if(typeof schemas[i] == 'object'){
  				var schema = schemas[i];
  				setupHierarchy(schema);
  				setupMethods(schema.methods, schema.prototype = schema.prototype || {});
  				setupMethods(schema.staticMethods, schema);
  				stores[schemas[i].id] = new dojox.data.PersevereStore({target:new dojo._Url(path,schemas[i].id) + '/',schema:schema});
  			}
  		}
  		return (results = stores);
  	});
  	dojo.xhr = plainXhr;
  	return sync ? results : dfd;
  };
  PersevereStore.addProxy = function(){
  	// summary:
  	//		Invokes the XHR proxy plugin. Call this if you will be using x-site data.
  	require("dojox/io/xhrPlugins"); // also not necessary, but we can register that Persevere supports proxying
  	dojox.io.xhrPlugins.addProxy("/proxy/");
  };
  
  return PersevereStore;
  
  });
  