|
|
declare namespace dojo {
|
|
|
namespace rpc {
|
|
|
|
|
|
/* dojo/rpc/JsonpService */
|
|
|
|
|
|
interface JsonpService<T> extends RpcService<T> {
|
|
|
strictArgChecks: boolean;
|
|
|
|
|
|
/**
|
|
|
* JSONP bind method. Takes remote method, parameters,
|
|
|
* deferred, and a url, calls createRequest to make a JSON-RPC
|
|
|
* envelope and passes that off with bind.
|
|
|
*/
|
|
|
bind(method: string, parameters: string[], deferredRequestHandler: dojo._base.Deferred<T>, url?: string): void;
|
|
|
|
|
|
/**
|
|
|
* create a JSONP req
|
|
|
*/
|
|
|
createRequest(parameters: string[]): string[];
|
|
|
}
|
|
|
|
|
|
interface JsonpServiceConstructor {
|
|
|
new <T>(args: string | RpcServiceArgs, requiredArgs: string[]): JsonpService<T>;
|
|
|
}
|
|
|
|
|
|
/* dojo/rpc/JsonService */
|
|
|
|
|
|
interface JsonService<T> extends RpcService<T> {
|
|
|
bustCache: boolean;
|
|
|
contentType: string;
|
|
|
lastSubmissionId: number;
|
|
|
|
|
|
/**
|
|
|
* call an arbitrary remote method without requiring it to be
|
|
|
* predefined with SMD
|
|
|
*/
|
|
|
callRemote<U>(method: string, params: string[]): dojo._base.Deferred<U>;
|
|
|
|
|
|
/**
|
|
|
* JSON-RPC bind method. Takes remote method, parameters,
|
|
|
* deferred, and a url, calls createRequest to make a JSON-RPC
|
|
|
* envelope and passes that off with bind.
|
|
|
*/
|
|
|
bind(method: string, parameters: string[], deferredRequestHandler: dojo._base.Deferred<T>, url: string): void;
|
|
|
|
|
|
/**
|
|
|
* create a JSON-RPC envelope for the request
|
|
|
*/
|
|
|
createRequest(method: string, params: string[]): string;
|
|
|
|
|
|
/**
|
|
|
* parse the result envelope and pass the results back to
|
|
|
* the callback function
|
|
|
*/
|
|
|
parseResults(obj: any): T;
|
|
|
}
|
|
|
|
|
|
interface JsonServiceConstructor {
|
|
|
new <T>(args: string | RpcServiceArgs): JsonService<T>;
|
|
|
}
|
|
|
|
|
|
/* dojo/rpc/RpcService */
|
|
|
|
|
|
interface SmdMethod {
|
|
|
name: string;
|
|
|
parameters?: string[];
|
|
|
url?: string;
|
|
|
serviceUrl?: string;
|
|
|
serviceURL?: string;
|
|
|
}
|
|
|
|
|
|
interface SmdObj {
|
|
|
methods?: SmdMethod[];
|
|
|
serviceUrl?: string;
|
|
|
serviceURL?: string;
|
|
|
required?: boolean;
|
|
|
}
|
|
|
|
|
|
interface RpcServiceArgs {
|
|
|
smdStr?: string;
|
|
|
serviceUrl?: string;
|
|
|
strictArgChecks?: boolean;
|
|
|
smdObj?: SmdObj;
|
|
|
}
|
|
|
|
|
|
interface RpcService<T> {
|
|
|
strictArgChecks: boolean;
|
|
|
serviceUrl: string;
|
|
|
|
|
|
/**
|
|
|
* parse the results coming back from an rpc request. this
|
|
|
* base implementation, just returns the full object
|
|
|
* subclasses should parse and only return the actual results
|
|
|
*/
|
|
|
parseResults(obj: any): T;
|
|
|
|
|
|
/**
|
|
|
* create callback that calls the Deferred errback method
|
|
|
*/
|
|
|
errorCallback(deferredRequestHandler: dojo._base.Deferred<T>): (data: any) => void;
|
|
|
|
|
|
/**
|
|
|
* create callback that calls the Deferred's callback method
|
|
|
*/
|
|
|
resultCallback(deferredRequestHandler: dojo._base.Deferred<T>): (obj: any) => void;
|
|
|
|
|
|
/**
|
|
|
* generate the local bind methods for the remote object
|
|
|
*/
|
|
|
generateMethod(method: string, parameters: string[], url: string): dojo._base.Deferred<T>;
|
|
|
|
|
|
/**
|
|
|
* callback method for receipt of a smd object. Parse the smd
|
|
|
* and generate functions based on the description
|
|
|
*/
|
|
|
processSmd(obj: SmdObj): void;
|
|
|
}
|
|
|
|
|
|
interface RpcServiceConstructor {
|
|
|
/**
|
|
|
* Take a string as a url to retrieve an smd or an object that is an smd or partial smd to use
|
|
|
* as a definition for the service
|
|
|
*/
|
|
|
new <T>(args: string | RpcServiceArgs): RpcService<T>;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
