|
|
/// <reference path="../dojo/index.d.ts" />
|
|
|
|
|
|
declare module dstore {
|
|
|
export interface FetchArray<T> extends Array<T> {
|
|
|
totalLength: number;
|
|
|
}
|
|
|
|
|
|
export interface FetchPromise<T> extends dojo.promise.Promise<T> {
|
|
|
totalLength: dojo.promise.Promise<number>;
|
|
|
}
|
|
|
|
|
|
export interface ChangeEvent<T> {
|
|
|
id: any;
|
|
|
index?: number;
|
|
|
previousIndex?: number;
|
|
|
target: T;
|
|
|
totalLength: number;
|
|
|
type: string;
|
|
|
}
|
|
|
|
|
|
export interface Collection<T> {
|
|
|
idProperty: string;
|
|
|
Model: { new (...args: any[]): T; };
|
|
|
tracking?: { remove(): void; };
|
|
|
|
|
|
add(object: T, options?: {}): dojo.promise.Promise<T>;
|
|
|
emit(eventName: string, event: ChangeEvent<T>): boolean;
|
|
|
fetch(): dstore.FetchPromise<T[]>;
|
|
|
fetchRange(kwArgs: { start?: number; end?: number; }): dstore.FetchPromise<T[]>;
|
|
|
filter(query: string | {} | { (item: T, index: number): boolean; }): this;
|
|
|
forEach(callback: (item: T, index: number) => void, thisObject?: any): dojo.promise.Promise<T[]>;
|
|
|
get(id: any): dojo.promise.Promise<T>;
|
|
|
getIdentity(object: T): any;
|
|
|
on(eventName: string, listener: (event: ChangeEvent<T>) => void): dojo.Handle;
|
|
|
put(object: T, options?: {}): dojo.promise.Promise<T>;
|
|
|
remove(id: any): dojo.promise.Promise<Object>;
|
|
|
sort(property: string | { (a: T, b: T): number; }, descending?: boolean): this;
|
|
|
track?(): this;
|
|
|
}
|
|
|
|
|
|
export interface SyncCollection<T> extends Collection<T> {
|
|
|
addSync(object: T, options?: {}): T;
|
|
|
fetchSync(): dstore.FetchArray<T>;
|
|
|
fetchRangeSync(kwArgs: { start?: number; end?: number; }): dstore.FetchArray<T>;
|
|
|
filter(query: string | {} | { (item: T, index: number): boolean; }): this;
|
|
|
getSync(id: any): T;
|
|
|
putSync(object: T, options?: {}): T;
|
|
|
removeSync(id: any): boolean;
|
|
|
sort(property: string | { (a: T, b: T): number; }, descending?: boolean): this;
|
|
|
track?(): this;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
declare module 'dstore/Cache' {
|
|
|
import Store = require('dstore/Store');
|
|
|
|
|
|
interface Cache<T> extends Store<T> {
|
|
|
cachingStore: dstore.Collection<T>;
|
|
|
evict(id: any): void;
|
|
|
}
|
|
|
|
|
|
module Cache {
|
|
|
export interface Constructor extends dojo._base.DeclareConstructor<Cache<any>> {
|
|
|
new <T>(kwArgs?: Cache.KwArgs<T>): Cache<T>;
|
|
|
}
|
|
|
|
|
|
export interface KwArgs<T> extends Store.KwArgs {
|
|
|
cachingStore?: dstore.Collection<T>;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const Cache: Cache.Constructor;
|
|
|
|
|
|
export = Cache;
|
|
|
}
|
|
|
|
|
|
declare module 'dstore/legacy/DstoreAdapter' {
|
|
|
import Store = require('dstore/Store');
|
|
|
|
|
|
interface DstoreAdapter<T> {
|
|
|
constructor(collection: dstore.Collection<T>): DstoreAdapter<T>;
|
|
|
get(id: any): any;
|
|
|
put(object: T, options?: {}): any;
|
|
|
remove(id: any): any;
|
|
|
query(query: any, options?: {}): any;
|
|
|
}
|
|
|
|
|
|
module DstoreAdapter {
|
|
|
export interface Constructor extends dojo._base.DeclareConstructor<DstoreAdapter<any>> {
|
|
|
new <T>(store: Store<T>): DstoreAdapter<Store<T>>;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const DstoreAdapter: DstoreAdapter.Constructor;
|
|
|
export = DstoreAdapter;
|
|
|
}
|
|
|
|
|
|
declare module 'dstore/Memory' {
|
|
|
import Store = require('dstore/Store');
|
|
|
|
|
|
interface Memory<T> extends Store<T>, dstore.SyncCollection<T> {
|
|
|
data: T[];
|
|
|
|
|
|
addSync(object: T, options?: {}): T;
|
|
|
fetchSync(): dstore.FetchArray<T>;
|
|
|
fetchRangeSync(kwArgs: { start?: number; end?: number; }): dstore.FetchArray<T>;
|
|
|
filter(query: string | {} | { (item: T, index: number): boolean; }): this;
|
|
|
getSync(id: any): T;
|
|
|
putSync(object: T, options?: {}): T;
|
|
|
removeSync(id: any): boolean;
|
|
|
setData(data: T[]): void;
|
|
|
sort(property: string | { (a: T, b: T): number; }, descending?: boolean): this;
|
|
|
track(): this;
|
|
|
remove(id: any): dojo.promise.Promise<{}>;
|
|
|
}
|
|
|
|
|
|
module Memory {
|
|
|
export interface Constructor extends dojo._base.DeclareConstructor<Memory<any>> {
|
|
|
new <T>(kwArgs?: Memory.KwArgs<T>): Memory<T>;
|
|
|
}
|
|
|
|
|
|
export interface KwArgs<T> extends Store.KwArgs {
|
|
|
data?: T[];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const Memory: Memory.Constructor;
|
|
|
|
|
|
export = Memory;
|
|
|
}
|
|
|
|
|
|
declare module 'dstore/Trackable' {
|
|
|
interface Trackable<T> {
|
|
|
currentRange: any[];
|
|
|
track(): this;
|
|
|
}
|
|
|
|
|
|
module Trackable {
|
|
|
export interface Constructor extends dojo._base.DeclareConstructor<Trackable<any>> {
|
|
|
new <T>(...args: any[]): Trackable<T>;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const Trackable: Trackable.Constructor;
|
|
|
|
|
|
export = Trackable;
|
|
|
}
|
|
|
|
|
|
declare module 'dstore/Tree' {
|
|
|
interface Tree<T> {
|
|
|
mayHaveChildren(object: T): boolean;
|
|
|
getRootCollection(): dstore.Collection<T>;
|
|
|
getChildren(object: T): dstore.Collection<T>;
|
|
|
}
|
|
|
|
|
|
module Tree {
|
|
|
export interface Constructor extends dojo._base.DeclareConstructor<Tree<any>> {
|
|
|
new <T>(...args: any[]): Tree<T>;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const Tree: Tree.Constructor;
|
|
|
|
|
|
export = Tree;
|
|
|
}
|
|
|
|
|
|
declare module 'dstore/Promised' {
|
|
|
import * as Promise from 'dojo/promise/Promise';
|
|
|
|
|
|
interface Promised<T> {
|
|
|
get(id: any): Promise<T>;
|
|
|
put(object: T, options?: {}): Promise<T>;
|
|
|
add(object: T, options?: {}): Promise<T>;
|
|
|
remove(id: any): Promise<boolean>;
|
|
|
fetch(): dstore.FetchPromise<T>;
|
|
|
fetchRange(args: { start?: number; end?: number; }): dstore.FetchPromise<T>;
|
|
|
}
|
|
|
|
|
|
module Promised {
|
|
|
export interface Constructor extends dojo._base.DeclareConstructor<Promised<any>> {
|
|
|
new <T>(...args: any[]): Promised<T>;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const Promised: Promised.Constructor;
|
|
|
|
|
|
export = Promised;
|
|
|
}
|
|
|
|
|
|
declare module 'dstore/SimpleQuery' {
|
|
|
interface SimpleQuery<T> {
|
|
|
}
|
|
|
|
|
|
module SimpleQuery {
|
|
|
export interface Constructor extends dojo._base.DeclareConstructor<SimpleQuery<any>> {
|
|
|
new <T>(...args: any[]): SimpleQuery<T>;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const SimpleQuery: SimpleQuery.Constructor;
|
|
|
|
|
|
export = SimpleQuery;
|
|
|
}
|
|
|
|
|
|
declare module 'dstore/Request' {
|
|
|
import Store = require('dstore/Store');
|
|
|
|
|
|
interface Request<T> extends Store<T> {
|
|
|
headers: {};
|
|
|
parse: (serializedObject: string) => {};
|
|
|
target: string;
|
|
|
ascendingPrefix: string;
|
|
|
descendingPrefix: string;
|
|
|
accepts: string;
|
|
|
|
|
|
track(): this;
|
|
|
}
|
|
|
|
|
|
module Request {
|
|
|
export interface Constructor extends dojo._base.DeclareConstructor<Request<any>> {
|
|
|
new <T>(kwArgs?: Request.KwArgs): Request<T>;
|
|
|
}
|
|
|
export interface KwArgs extends Store.KwArgs {
|
|
|
headers?: typeof Request.prototype.headers;
|
|
|
parse?: typeof Request.prototype.parse;
|
|
|
target?: typeof Request.prototype.target;
|
|
|
ascendingPrefix?: typeof Request.prototype.ascendingPrefix;
|
|
|
descendingPrefix?: typeof Request.prototype.descendingPrefix;
|
|
|
accepts?: typeof Request.prototype.accepts;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const Request: Request.Constructor;
|
|
|
|
|
|
export = Request;
|
|
|
}
|
|
|
|
|
|
declare module 'dstore/RequestMemory' {
|
|
|
import Request = require('dstore/Request');
|
|
|
import Cache = require('dstore/Cache');
|
|
|
|
|
|
interface RequestMemory<T> extends Request<T>, Cache<T> {
|
|
|
cachingStore: dstore.Collection<T>;
|
|
|
evict(id: any): void;
|
|
|
|
|
|
track(): this;
|
|
|
}
|
|
|
|
|
|
module RequestMemory {
|
|
|
export interface Constructor extends dojo._base.DeclareConstructor<RequestMemory<any>> {
|
|
|
new <T>(kwArgs?: RequestMemory.KwArgs<T>): RequestMemory<T>;
|
|
|
}
|
|
|
|
|
|
export interface KwArgs<T> extends Request.KwArgs, Cache.KwArgs<T> {}
|
|
|
}
|
|
|
|
|
|
const RequestMemory: RequestMemory.Constructor;
|
|
|
|
|
|
export = RequestMemory;
|
|
|
}
|
|
|
|
|
|
declare module 'dstore/Rest' {
|
|
|
import Request = require('dstore/Request');
|
|
|
|
|
|
interface Rest<T> extends Request<T> {}
|
|
|
|
|
|
module Rest {
|
|
|
export interface Constructor extends dojo._base.DeclareConstructor<Rest<any>> {
|
|
|
new <T>(kwArgs?: Request.KwArgs): Rest<T>;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const Rest: Rest.Constructor;
|
|
|
|
|
|
export = Rest;
|
|
|
}
|
|
|
|
|
|
declare module 'dstore/Store' {
|
|
|
interface Store<T> extends dstore.Collection<T> {
|
|
|
idProperty: string;
|
|
|
Model: { new (...args: any[]): T; };
|
|
|
total: dojo.promise.Promise<number>;
|
|
|
|
|
|
add(object: T, options?: {}): dojo.promise.Promise<T>;
|
|
|
emit(eventName: string, event: dstore.ChangeEvent<T>): boolean;
|
|
|
fetch(): dstore.FetchPromise<T[]>;
|
|
|
fetchRange(kwArgs: { start?: number; end?: number; }): dstore.FetchPromise<T[]>;
|
|
|
filter(query: string | {} | { (item: T, index: number): boolean; }): this;
|
|
|
forEach(callback: (item: T, index: number) => void, thisObject?: any): dojo.promise.Promise<T[]>;
|
|
|
get(id: any): dojo.promise.Promise<T>;
|
|
|
getIdentity(object: T): any;
|
|
|
on(eventName: string, listener: (event: dstore.ChangeEvent<T>) => void): dojo.Handle;
|
|
|
put(object: T, options?: {}): dojo.promise.Promise<T>;
|
|
|
remove(id: any): dojo.promise.Promise<{}>;
|
|
|
sort(property: string | { (a: T, b: T): number; }, descending?: boolean): this;
|
|
|
}
|
|
|
|
|
|
module Store {
|
|
|
export interface Constructor extends dojo._base.DeclareConstructor<Store<any>> {
|
|
|
new <T>(kwArgs?: Store.KwArgs): Store<T>;
|
|
|
}
|
|
|
|
|
|
export interface KwArgs {
|
|
|
idProperty?: typeof Store.prototype.idProperty;
|
|
|
Model?: typeof Store.prototype.Model;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const Store: Store.Constructor;
|
|
|
|
|
|
export = Store;
|
|
|
}
|
|
|
|
