|
|
/// <reference path="promise.d.ts" />
|
|
|
/// <reference path="data.d.ts" />
|
|
|
|
|
|
|
|
|
declare namespace dojo {
|
|
|
namespace store {
|
|
|
namespace api {
|
|
|
|
|
|
type Identity = number | string;
|
|
|
|
|
|
/* dojo/store/api/Store */
|
|
|
|
|
|
interface SortInformation {
|
|
|
|
|
|
/**
|
|
|
* The name of the attribute to sort on.
|
|
|
*/
|
|
|
attribute: string;
|
|
|
|
|
|
/**
|
|
|
* The direction of the sort. Default is false.
|
|
|
*/
|
|
|
descending?: boolean;
|
|
|
}
|
|
|
|
|
|
interface QueryOptions {
|
|
|
/**
|
|
|
* A list of attributes to sort on, as well as direction
|
|
|
* For example:
|
|
|
* | [{attribute:"price", descending: true}].
|
|
|
* If the sort parameter is omitted, then the natural order of the store may be
|
|
|
* applied if there is a natural order.
|
|
|
*/
|
|
|
sort?: SortInformation[];
|
|
|
|
|
|
/**
|
|
|
* The first result to begin iteration on
|
|
|
*/
|
|
|
start?: number;
|
|
|
|
|
|
/**
|
|
|
* The number of how many results should be returned.
|
|
|
*/
|
|
|
count?: number;
|
|
|
}
|
|
|
|
|
|
interface QueryEngineFunction<T extends object> {
|
|
|
(array: T[]): T[];
|
|
|
matches(object: T): boolean;
|
|
|
}
|
|
|
|
|
|
type BaseQueryType = string | object | ((...params: any[]) => any);
|
|
|
|
|
|
interface QueryEngine<T extends object, Q extends BaseQueryType> {
|
|
|
<O extends QueryOptions>(query: Q, options?: O): QueryEngineFunction<T>;
|
|
|
}
|
|
|
|
|
|
interface PutDirectives<T extends object> {
|
|
|
|
|
|
/**
|
|
|
* Indicates the identity of the object if a new object is created
|
|
|
*/
|
|
|
id?: Identity;
|
|
|
|
|
|
/**
|
|
|
* If the collection of objects in the store has a natural ordering,
|
|
|
* this indicates that the created or updated object should be placed before the
|
|
|
* object specified by the value of this property. A value of null indicates that the
|
|
|
* object should be last.
|
|
|
*/
|
|
|
before?: T;
|
|
|
|
|
|
/**
|
|
|
* If the store is hierarchical (with single parenting) this property indicates the
|
|
|
* new parent of the created or updated object.
|
|
|
*/
|
|
|
parent?: T;
|
|
|
|
|
|
/**
|
|
|
* If this is provided as a boolean it indicates that the object should or should not
|
|
|
* overwrite an existing object. A value of true indicates that a new object
|
|
|
* should not be created, the operation should update an existing object. A
|
|
|
* value of false indicates that an existing object should not be updated, a new
|
|
|
* object should be created (which is the same as an add() operation). When
|
|
|
* this property is not provided, either an update or creation is acceptable.
|
|
|
*/
|
|
|
overwrite?: boolean;
|
|
|
}
|
|
|
|
|
|
interface SyncQueryResults<T extends object> extends Array<T> {
|
|
|
total?: number;
|
|
|
}
|
|
|
|
|
|
interface AsyncQueryResults<T extends object> extends PromiseLike<Array<T>> {
|
|
|
/**
|
|
|
* Iterates over the query results, based on
|
|
|
* https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/objects/Array/forEach.
|
|
|
* Note that this may executed asynchronously. The callback may be called
|
|
|
* after this function returns.
|
|
|
*/
|
|
|
forEach(callback: (item: T, index: number, results: Array<T>) => void, thisObject?: object): PromiseLike<void>;
|
|
|
|
|
|
/**
|
|
|
* Filters the query results, based on
|
|
|
* https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter.
|
|
|
* Note that this may executed asynchronously. The callback may be called
|
|
|
* after this function returns.
|
|
|
*/
|
|
|
filter(callback: (item: T, index: number, results: Array<T>) => boolean, thisObject?: object): PromiseLike<Array<T>>;
|
|
|
|
|
|
/**
|
|
|
* Maps the query results, based on
|
|
|
* https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map.
|
|
|
* Note that this may executed asynchronously. The callback may be called
|
|
|
* after this function returns.
|
|
|
*/
|
|
|
map<U>(callback: (item: T, index: number, results: Array<T>) => U, thisObject?: object): PromiseLike<Array<U>>;
|
|
|
|
|
|
/** Cancells the current query */
|
|
|
cancel(reason?: any): void;
|
|
|
|
|
|
total?: PromiseLike<number>;
|
|
|
}
|
|
|
|
|
|
type QueryResults<T extends object> = SyncQueryResults<T> | AsyncQueryResults<T>;
|
|
|
|
|
|
interface Transaction {
|
|
|
/**
|
|
|
* Commits the transaction. This may throw an error if it fails. Of if the operation
|
|
|
* is asynchronous, it may return a promise that represents the eventual success
|
|
|
* or failure of the commit.
|
|
|
*/
|
|
|
commit(): void;
|
|
|
|
|
|
/**
|
|
|
* Aborts the transaction. This may throw an error if it fails. Of if the operation
|
|
|
* is asynchronous, it may return a promise that represents the eventual success
|
|
|
* or failure of the abort.
|
|
|
*/
|
|
|
abort(): void;
|
|
|
}
|
|
|
|
|
|
interface Transacted {
|
|
|
/**
|
|
|
* Starts a new transaction.
|
|
|
* Note that a store user might not call transaction() prior to using put,
|
|
|
* delete, etc. in which case these operations effectively could be thought of
|
|
|
* as "auto-commit" style actions.
|
|
|
*/
|
|
|
transaction(): Transaction;
|
|
|
}
|
|
|
|
|
|
interface MetadataProvider<T extends object> {
|
|
|
/**
|
|
|
* Returns any metadata about the object. This may include attribution,
|
|
|
* cache directives, history, or version information.
|
|
|
*/
|
|
|
getMetadata(object: T): object;
|
|
|
}
|
|
|
|
|
|
interface IdentityProvider<T extends object> {
|
|
|
/**
|
|
|
* If the store has a single primary key, this indicates the property to use as the
|
|
|
* identity property. The values of this property should be unique.
|
|
|
*/
|
|
|
idProperty: keyof T;
|
|
|
|
|
|
/**
|
|
|
* Returns an object's identity
|
|
|
*/
|
|
|
getIdentity(object: T): Identity;
|
|
|
}
|
|
|
|
|
|
interface Queryable<
|
|
|
T extends object,
|
|
|
Q extends BaseQueryType,
|
|
|
O extends QueryOptions,
|
|
|
R extends QueryResults<T> = QueryResults<T>> {
|
|
|
|
|
|
/**
|
|
|
* Queries the store for objects. This does not alter the store, but returns a
|
|
|
* set of data from the store.
|
|
|
*/
|
|
|
query(query?: Q, options?: O): R;
|
|
|
}
|
|
|
|
|
|
interface SyncStore<T extends object, Q extends BaseQueryType = Partial<T> | ((item: T) => boolean) | string, O extends QueryOptions = QueryOptions>
|
|
|
extends IdentityProvider<T>, Queryable<T, Q, O, SyncQueryResults<T>> {
|
|
|
|
|
|
/**
|
|
|
* If the store can be queried locally (on the client side in JS), this defines
|
|
|
* the query engine to use for querying the data store.
|
|
|
* This takes a query and query options and returns a function that can execute
|
|
|
* the provided query on a JavaScript array. The queryEngine may be replace to
|
|
|
* provide more sophisticated querying capabilities. For example:
|
|
|
* | var query = store.queryEngine({foo:"bar"}, {count:10});
|
|
|
* | query(someArray) -> filtered array
|
|
|
* The returned query function may have a "matches" property that can be
|
|
|
* used to determine if an object matches the query. For example:
|
|
|
* | query.matches({id:"some-object", foo:"bar"}) -> true
|
|
|
* | query.matches({id:"some-object", foo:"something else"}) -> false
|
|
|
*/
|
|
|
queryEngine?: QueryEngine<T, Q>;
|
|
|
|
|
|
/**
|
|
|
* Retrieves an object by its identity
|
|
|
*/
|
|
|
get(id: Identity): T;
|
|
|
|
|
|
/**
|
|
|
* Stores an object
|
|
|
*/
|
|
|
put(object: T, directives?: PutDirectives<T>): any;
|
|
|
|
|
|
/**
|
|
|
* Creates an object, throws an error if the object already exists
|
|
|
*/
|
|
|
add(object: T, directives?: PutDirectives<T>): any;
|
|
|
|
|
|
/**
|
|
|
* Deletes an object by its identity
|
|
|
*/
|
|
|
remove(id: Identity): void;
|
|
|
|
|
|
}
|
|
|
|
|
|
interface AsyncStore<T extends object, Q extends BaseQueryType = Partial<T> | ((item: T) => boolean) | string, O extends QueryOptions = QueryOptions>
|
|
|
extends IdentityProvider<T>, Queryable<T, Q, O, AsyncQueryResults<T>> {
|
|
|
|
|
|
/**
|
|
|
* If the store can be queried locally (on the client side in JS), this defines
|
|
|
* the query engine to use for querying the data store.
|
|
|
* This takes a query and query options and returns a function that can execute
|
|
|
* the provided query on a JavaScript array. The queryEngine may be replace to
|
|
|
* provide more sophisticated querying capabilities. For example:
|
|
|
* | var query = store.queryEngine({foo:"bar"}, {count:10});
|
|
|
* | query(someArray) -> filtered array
|
|
|
* The returned query function may have a "matches" property that can be
|
|
|
* used to determine if an object matches the query. For example:
|
|
|
* | query.matches({id:"some-object", foo:"bar"}) -> true
|
|
|
* | query.matches({id:"some-object", foo:"something else"}) -> false
|
|
|
*/
|
|
|
queryEngine?: QueryEngine<T, Q>;
|
|
|
|
|
|
/**
|
|
|
* Retrieves an object by its identity
|
|
|
*/
|
|
|
get(id: Identity): promise.Promise<T>;
|
|
|
|
|
|
/**
|
|
|
* Stores an object
|
|
|
*/
|
|
|
put(object: T, directives?: PutDirectives<T>): promise.Promise<any>;
|
|
|
|
|
|
/**
|
|
|
* Creates an object, throws an error if the object already exists
|
|
|
*/
|
|
|
add(object: T, directives?: PutDirectives<T>): promise.Promise<any>;
|
|
|
|
|
|
/**
|
|
|
* Deletes an object by its identity
|
|
|
*/
|
|
|
remove(id: string | number): promise.Promise<void>;
|
|
|
|
|
|
}
|
|
|
|
|
|
interface HierarchicalStore<T extends object, O extends QueryOptions = QueryOptions, R extends QueryResults<T> = QueryResults<T>> {
|
|
|
|
|
|
/**
|
|
|
* Retrieves the children of an object.
|
|
|
*/
|
|
|
getChildren(parent: T, options?: O): R;
|
|
|
}
|
|
|
|
|
|
interface Store<T extends object, Q extends BaseQueryType = Partial<T> | ((item: T) => boolean) | string, O extends QueryOptions = QueryOptions>
|
|
|
extends IdentityProvider<T>, Queryable<T, Q, O> {
|
|
|
|
|
|
/**
|
|
|
* If the store can be queried locally (on the client side in JS), this defines
|
|
|
* the query engine to use for querying the data store.
|
|
|
* This takes a query and query options and returns a function that can execute
|
|
|
* the provided query on a JavaScript array. The queryEngine may be replace to
|
|
|
* provide more sophisticated querying capabilities. For example:
|
|
|
* | var query = store.queryEngine({foo:"bar"}, {count:10});
|
|
|
* | query(someArray) -> filtered array
|
|
|
* The returned query function may have a "matches" property that can be
|
|
|
* used to determine if an object matches the query. For example:
|
|
|
* | query.matches({id:"some-object", foo:"bar"}) -> true
|
|
|
* | query.matches({id:"some-object", foo:"something else"}) -> false
|
|
|
*/
|
|
|
queryEngine?: QueryEngine<T, Q>;
|
|
|
|
|
|
/**
|
|
|
* Retrieves an object by its identity
|
|
|
*/
|
|
|
get(id: Identity): T | promise.Promise<T>;
|
|
|
|
|
|
/**
|
|
|
* Stores an object
|
|
|
*/
|
|
|
put(object: T, directives?: PutDirectives<T>): any;
|
|
|
|
|
|
/**
|
|
|
* Creates an object, throws an error if the object already exists
|
|
|
*/
|
|
|
add(object: T, directives?: PutDirectives<T>): any;
|
|
|
|
|
|
/**
|
|
|
* Deletes an object by its identity
|
|
|
*/
|
|
|
remove(id: Identity): void | promise.Promise<void>;
|
|
|
|
|
|
}
|
|
|
|
|
|
interface StoreConstructor {
|
|
|
new <T extends object, Q extends BaseQueryType, O extends QueryOptions>(): Store<T, Q, O>;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
namespace util {
|
|
|
|
|
|
/* dojo/store/util/QueryResults */
|
|
|
|
|
|
interface QueryResultsFunction {
|
|
|
/**
|
|
|
* A function that wraps the results of a store query with additional
|
|
|
* methods.
|
|
|
*/
|
|
|
<T extends object>(results: T[]): api.SyncQueryResults<T>;
|
|
|
<T extends object>(results: PromiseLike<T[]>): api.AsyncQueryResults<T>;
|
|
|
}
|
|
|
|
|
|
/* dojo/store/util/SimpleQueryEngine */
|
|
|
interface SimpleQueryEngine extends api.QueryEngine<object, api.BaseQueryType> { }
|
|
|
}
|
|
|
|
|
|
/* dojo/store/Cache */
|
|
|
|
|
|
interface CacheOptions<T extends object = any> {
|
|
|
/**
|
|
|
* This is a function that will be called for each item in a query response to determine
|
|
|
* if it is cacheable. If isLoaded returns true, the item will be cached, otherwise it
|
|
|
* will not be cached. If isLoaded is not provided, all items will be cached.
|
|
|
*/
|
|
|
isLoaded?: (item: T) => boolean;
|
|
|
}
|
|
|
|
|
|
interface CacheMixin {
|
|
|
/**
|
|
|
* Remove the object with the specific id.
|
|
|
*/
|
|
|
remove(id: api.Identity): promise.Promise<void>;
|
|
|
|
|
|
/**
|
|
|
* Remove the object with the given id from the underlying caching store.
|
|
|
*/
|
|
|
evict(id: api.Identity): promise.Promise<void>;
|
|
|
}
|
|
|
|
|
|
interface Cache {
|
|
|
/**
|
|
|
* The Cache store wrapper takes a master store and a caching store,
|
|
|
* caches data from the master into the caching store for faster
|
|
|
* lookup. Normally one would use a memory store for the caching
|
|
|
* store and a server store like JsonRest for the master store.
|
|
|
*/
|
|
|
<T extends object, Q extends api.BaseQueryType, O extends api.QueryOptions, S extends api.Store<T, Q, O>>(masterStore: S, cacheStore: api.Store<T, Q, O>, options?: CacheOptions): CacheMixin & S;
|
|
|
}
|
|
|
|
|
|
/* dojo/store/DataStore */
|
|
|
|
|
|
interface DataStoreOptions<T extends object> {
|
|
|
idProperty?: keyof T;
|
|
|
queryEngine?: api.QueryEngine<T, api.QueryOptions>;
|
|
|
store?: data.api.Read<T> | data.api.Write<T> | data.api.Identity<T>;
|
|
|
}
|
|
|
|
|
|
interface DataStore<T extends object> extends api.Store<T, api.BaseQueryType, api.QueryOptions> {
|
|
|
/**
|
|
|
* The object store to convert to a data store
|
|
|
*/
|
|
|
store: data.api.Read<T> | data.api.Write<T> | data.api.Identity<T>;
|
|
|
|
|
|
/**
|
|
|
* Defines the query engine to use for querying the data store
|
|
|
*/
|
|
|
queryEngine: api.QueryEngine<T, api.BaseQueryType>;
|
|
|
|
|
|
_objectConverter(callback: (item: T) => any): (item: T) => any;
|
|
|
}
|
|
|
|
|
|
interface DataStoreConstructor extends _base.DeclareConstructor<DataStore<object>> {
|
|
|
new <T extends object>(options?: DataStoreOptions<T>): DataStore<T>;
|
|
|
}
|
|
|
|
|
|
/* dojo/store/JsonRest */
|
|
|
|
|
|
interface Headers {
|
|
|
[header: string]: string;
|
|
|
}
|
|
|
|
|
|
interface JsonRestPutDirectives<T extends object> extends api.PutDirectives<T> {
|
|
|
headers?: Headers;
|
|
|
|
|
|
incremental?: boolean;
|
|
|
|
|
|
timeout?: number
|
|
|
}
|
|
|
|
|
|
interface JsonRestQueryOptions extends api.QueryOptions {
|
|
|
headers?: Headers;
|
|
|
|
|
|
timeout?: number;
|
|
|
}
|
|
|
|
|
|
interface JsonRestOptions<T extends object> {
|
|
|
idProperty?: keyof T;
|
|
|
queryEngine?: api.QueryEngine<T, JsonRestQueryOptions>;
|
|
|
headers?: Headers;
|
|
|
target?: string;
|
|
|
rangeParam?: string;
|
|
|
sortParam?: string;
|
|
|
ascendingPrefix?: string;
|
|
|
descendingPrefix?: string;
|
|
|
accepts?: string;
|
|
|
}
|
|
|
|
|
|
interface JsonRest<
|
|
|
T extends object,
|
|
|
Q extends api.BaseQueryType = (Partial<T> | string) & api.BaseQueryType,
|
|
|
O extends JsonRestQueryOptions = JsonRestQueryOptions>
|
|
|
extends api.AsyncStore<T, Q, O> {
|
|
|
/**
|
|
|
* Additional headers to pass in all requests to the server. These can be overridden
|
|
|
* by passing additional headers to calls to the store.
|
|
|
*/
|
|
|
headers: Headers;
|
|
|
|
|
|
/**
|
|
|
* The target base URL to use for all requests to the server. This string will be
|
|
|
* prepended to the id to generate the URL (relative or absolute) for requests
|
|
|
* sent to the server
|
|
|
*/
|
|
|
target: string;
|
|
|
|
|
|
/**
|
|
|
* Use a query parameter for the requested range. If this is omitted, than the
|
|
|
* Range header will be used. Independent of this, the X-Range header is always set.
|
|
|
*/
|
|
|
rangeParam?: string;
|
|
|
|
|
|
/**
|
|
|
* The query parameter to used for holding sort information. If this is omitted, than
|
|
|
* the sort information is included in a functional query token to avoid colliding
|
|
|
* with the set of name/value pairs.
|
|
|
*/
|
|
|
sortParam?: string;
|
|
|
|
|
|
/**
|
|
|
* The prefix to apply to sort attribute names that are ascending
|
|
|
*/
|
|
|
ascendingPrefix: string;
|
|
|
|
|
|
/**
|
|
|
* The prefix to apply to sort attribute names that are descending
|
|
|
*/
|
|
|
descendingPrefix: string;
|
|
|
|
|
|
/**
|
|
|
* If the target has no trailing '/', then append it.
|
|
|
*/
|
|
|
_getTarget(id: api.Identity): string;
|
|
|
|
|
|
/**
|
|
|
* Retrieves an object by its identity. This will trigger a GET request to the server using
|
|
|
* the url `this.target + id`.
|
|
|
*/
|
|
|
get(id: api.Identity, options?: { headers: Headers } | Headers): promise.Promise<T>;
|
|
|
|
|
|
/**
|
|
|
* Defines the Accept header to use on HTTP requests
|
|
|
*/
|
|
|
accepts: string;
|
|
|
|
|
|
/**
|
|
|
* Stores an object. This will trigger a PUT request to the server
|
|
|
* if the object has an id, otherwise it will trigger a POST request.
|
|
|
*/
|
|
|
put(object: T, options?: JsonRestPutDirectives<T>): promise.Promise<any>;
|
|
|
|
|
|
/**
|
|
|
* Adds an object. This will trigger a PUT request to the server
|
|
|
* if the object has an id, otherwise it will trigger a POST request.
|
|
|
*/
|
|
|
add(object: T, options?: JsonRestPutDirectives<T>): promise.Promise<any>;
|
|
|
|
|
|
/**
|
|
|
* Deletes an object by its identity. This will trigger a DELETE request to the server.
|
|
|
*/
|
|
|
remove(id: api.Identity, options?: { headers?: Headers }): promise.Promise<void>;
|
|
|
|
|
|
}
|
|
|
|
|
|
interface JsonRestConstructor extends _base.DeclareConstructor<JsonRest<object, api.BaseQueryType, JsonRestQueryOptions>> {
|
|
|
new <T extends object, Q extends api.BaseQueryType, O extends JsonRestQueryOptions>(options?: JsonRestOptions<T>): JsonRest<T, Q, O>;
|
|
|
}
|
|
|
|
|
|
/* dojo/store/Memory */
|
|
|
|
|
|
interface MemoryOptions<T extends object> {
|
|
|
data?: T[];
|
|
|
idProperty?: keyof T;
|
|
|
queryEngine?: api.QueryEngine<T, api.QueryOptions>;
|
|
|
setData?: (data: T[]) => void;
|
|
|
}
|
|
|
|
|
|
interface Memory<T extends object> extends api.SyncStore<T> {
|
|
|
/**
|
|
|
* The array of all the objects in the memory store
|
|
|
*/
|
|
|
data: T[];
|
|
|
|
|
|
/**
|
|
|
* An index of data indices into the data array by id
|
|
|
*/
|
|
|
index: { [id: string]: number };
|
|
|
|
|
|
/**
|
|
|
* Sets the given data as the source for this store, and indexes it
|
|
|
*/
|
|
|
setData(data: T[]): void;
|
|
|
}
|
|
|
|
|
|
interface MemoryConstructor extends _base.DeclareConstructor<Memory<any>> {
|
|
|
/**
|
|
|
* This is a basic in-memory object store. It implements dojo/store/api/Store.
|
|
|
*/
|
|
|
new <T extends object>(options?: MemoryOptions<T>): Memory<T>;
|
|
|
}
|
|
|
|
|
|
/* dojo/store/Observable */
|
|
|
|
|
|
interface ObservableQueryResultsMixin<T extends object> {
|
|
|
/**
|
|
|
* Allows observation of results
|
|
|
*/
|
|
|
observe(listener: (object: T, previousIndex: number, newIndex: number) => void, includeUpdates?: boolean): {
|
|
|
remove(): void;
|
|
|
cancel(): void;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
type ObservableQueryResults<T extends object> = ObservableQueryResultsMixin<T> & api.QueryResults<T>;
|
|
|
|
|
|
interface ObservableMixin<T extends object, Q extends api.BaseQueryType, O extends api.QueryOptions, R extends api.QueryResults<T> = api.QueryResults<T> > {
|
|
|
notify(object: T, existingId?: api.Identity): void;
|
|
|
|
|
|
/**
|
|
|
* Queries the store for objects. This does not alter the store, but returns a
|
|
|
* set of data from the store.
|
|
|
*/
|
|
|
query(query: Q, options?: O): ObservableQueryResultsMixin<T> & R;
|
|
|
}
|
|
|
|
|
|
interface ResultsObserveMixin<T extends object> {
|
|
|
/**
|
|
|
* Allows observation of results
|
|
|
*/
|
|
|
observe(listener: (object: T, previousIndex: number, newIndex: number) => void, includeUpdates?: boolean): {
|
|
|
remove(): void;
|
|
|
cancel(): void;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
interface Notifiable<T> {
|
|
|
notify(object: T, existingId?: api.Identity): void;
|
|
|
}
|
|
|
|
|
|
type ResultItem<R> = R extends ArrayLike<infer I1> ? I1 :
|
|
|
R extends PromiseLike<ArrayLike<infer I2>> ? I2 : never;
|
|
|
|
|
|
type ObservableStore<S extends { query: (...params: any) => any }> =
|
|
|
S extends { query: (...params: infer P) => api.QueryResults<infer R> } ? {
|
|
|
[K in keyof S]: K extends "query" ? (...params: P) => ReturnType<S[K]> & ResultsObserveMixin<R> : S[K];
|
|
|
} & Notifiable<R> : S;
|
|
|
|
|
|
interface Observable {
|
|
|
new <S extends api.Store<any, any, any>>(store: S): ObservableStore<S>;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
