##// END OF EJS Templates
implab » implabjs-dojo-typings
RSS
_WidgetBase some attributes made optional
_WidgetBase some attributes made optional
cin - - Load All Authors

File last commit:

r4:c7a87ad80f91 default
r18:8ab7be820af9 v1.0.7 default
Show More
dstore.d.ts
312 lines | 8.3 KiB | video/mp2t | TypeScriptLexer
/ dojo-typings / src / main / typings / dstore / dstore.d.ts
History | Source | Raw |Copy content |Copy permalink
cin
Fixed build script, added dgrid, added dstore typings.
 r4 /// <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;
}