vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2026-08-13 13:30:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/borisyankov/DefinitelyTyped

Browse Source
This commit is contained in:
Christiaan Rakowski
2013-07-03 10:34:08 +02:00
parent 0ceefdb6c9 84b94b51cb
commit 922e87eeca
14 changed files with 1212 additions and 1022 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backbone/backbone.d.ts
Vendored
+1 -1
View File
@@ -271,7 +271,7 @@ declare module Backbone {
navigate(fragment: string, options?: any);
started: boolean;
_updateHash(location: Location, fragment: string, replace: bool);
_updateHash(location: Location, fragment: string, replace: boolean);
}
interface ViewOptions {
fullCalendar/fullCalendar-tests.ts
+2 -2
View File
@@ -87,7 +87,7 @@ $('#calendar').fullCalendar({
}
});
var view: FullCalendar.View = <any>$('#calendar').fullCalendar('getView');
var view = $('#calendar').fullCalendar('getView');
alert("The view's title is " + view.title);
$(document).ready(function () {
@@ -407,7 +407,7 @@ $('#my-today-button').click(function () {
$('#calendar').fullCalendar('gotoDate', 1, 0, 1);
$('#my-button').click(function () {
var d: Date = <any>$('#calendar').fullCalendar('getDate');
var d = $('#calendar').fullCalendar('getDate');
alert("The current date of the calendar is " + d);
});
fullCalendar/fullCalendar.d.ts
Vendored
+27 -1
View File
@@ -180,7 +180,33 @@ declare module FullCalendar {
interface JQuery {
fullCalendar(options: FullCalendar.Options): JQuery;
fullCalendar(method: string, ...args: Array<any>): JQuery;
fullCalendar(method: string, arg1: any, arg2: any, arg3: any): void;
fullCalendar(method: 'option', option: string, value?: any): void;
fullCalendar(method: 'render'): void;
fullCalendar(method: 'destroy'): void;
fullCalendar(method: 'prev'): void;
fullCalendar(method: 'next'): void;
fullCalendar(method: 'prevYear'): void;
fullCalendar(method: 'nextYear'): void;
fullCalendar(method: 'today'): void;
fullCalendar(method: 'getView'): FullCalendar.View;
fullCalendar(method: 'changeView', viewName: string): void;
fullCalendar(method: 'gotoDate', year: number, month?: number, date?: number): void;
fullCalendar(method: 'gotoDate', date: Date): void;
fullCalendar(method: 'incrementDate', year: number, month?: number, date?: number): void;
fullCalendar(method: 'getDate'): Date;
fullCalendar(method: 'select', startDate: Date, endDate: Date, allDay: boolean): void;
fullCalendar(method: 'unselect'): void;
fullCalendar(method: 'updateEvent', event: FullCalendar.EventObject): void;
fullCalendar(method: 'clientEvents', idOrfilter?: any): Array<FullCalendar.EventObject>;
fullCalendar(method: 'clientEvents', idOrfilter?: (e: FullCalendar.EventObject) => boolean): Array<FullCalendar.EventObject>;
fullCalendar(method: 'removeEvents', idOrfilter?: any): void;
fullCalendar(method: 'removeEvents', idOrfilter?: (e: FullCalendar.EventObject) => boolean): void;
fullCalendar(method: 'refreshEvents'): void;
fullCalendar(method: 'addEventSource', source: any): void;
fullCalendar(method: 'removeEventSource', source: any): void;
fullCalendar(method: 'renderEvent', event: FullCalendar.EventObject, stick?: boolean): void;
fullCalendar(method: 'rerenderEvents'): void;
}
interface JQueryStatic {
hammerjs/hammerjs.d.ts
Vendored
+11 -11
View File
@@ -7,24 +7,24 @@
/// <reference path="../jquery/jquery.d.ts"/>
interface HammerOptions {
prevent_default?: bool;
css_hacks?: bool;
swipe?: bool;
prevent_default?: boolean;
css_hacks?: boolean;
swipe?: boolean;
swipe_time?: number;
swipe_min_distance?: number;
drag?: bool;
drag_vertical?: bool;
drag_horizontal?: bool;
drag?: boolean;
drag_vertical?: boolean;
drag_horizontal?: boolean;
drag_min_distance?: number;
transform?: bool;
transform?: boolean;
scale_treshold?: number;
rotation_treshold?: number;
tap?: bool;
tap_double?: bool;
tap?: boolean;
tap_double?: boolean;
tap_max_interval?: number;
tap_max_distance?: number;
tap_double_distance?: number;
hold?: bool;
hold?: boolean;
hold_timeout?: number;
}
@@ -70,4 +70,4 @@ declare class Hammer {
interface JQuery {
hammer(options?: HammerOptions): JQuery;
}
}
handlebars/handlebars.d.ts
Vendored
+2 -2
View File
@@ -5,7 +5,7 @@
interface HandlebarsStatic {
registerHelper(name: string, fn: Function, inverse?: bool): void;
registerHelper(name: string, fn: Function, inverse?: boolean): void;
registerPartial(name: string, str): void;
K();
createFrame(object);
@@ -20,4 +20,4 @@ interface HandlebarsStatic {
compile(environment, options?, context?, asObject?);
}
declare var Handlebars: HandlebarsStatic;
declare var Handlebars: HandlebarsStatic;
jqueryui/jqueryui.d.ts
Vendored
+118
View File
@@ -782,6 +782,11 @@ interface JQuery {
accordion(): JQuery;
accordion(methodName: string): JQuery;
accordion(methodName: 'destroy'): void;
accordion(methodName: 'disable'): void;
accordion(methodName: 'enable'): void;
accordion(methodName: 'refresh'): void;
accordion(methodName: 'widget'): JQuery;
accordion(options: JQueryUI.AccordionOptions): JQuery;
accordion(optionLiteral: string, optionName: string): any;
accordion(optionLiteral: string, options: JQueryUI.AccordionOptions): any;
@@ -789,6 +794,12 @@ interface JQuery {
autocomplete(): JQuery;
autocomplete(methodName: string): JQuery;
autocomplete(methodName: 'close'): void;
autocomplete(methodName: 'destroy'): void;
autocomplete(methodName: 'disable'): void;
autocomplete(methodName: 'enable'): void;
autocomplete(methodName: 'search', value?: string): void;
autocomplete(methodName: 'widget'): JQuery;
autocomplete(options: JQueryUI.AutocompleteOptions): JQuery;
autocomplete(optionLiteral: string, optionName: string): any;
autocomplete(optionLiteral: string, options: JQueryUI.AutocompleteOptions): any;
@@ -796,6 +807,11 @@ interface JQuery {
button(): JQuery;
button(methodName: string): JQuery;
button(methodName: 'destroy'): void;
button(methodName: 'disable'): void;
button(methodName: 'enable'): void;
button(methodName: 'refresh'): void;
button(methodName: 'widget'): JQuery;
button(options: JQueryUI.ButtonOptions): JQuery;
button(optionLiteral: string, optionName: string): any;
button(optionLiteral: string, options: JQueryUI.ButtonOptions): any;
@@ -803,6 +819,11 @@ interface JQuery {
buttonset(): JQuery;
buttonset(methodName: string): JQuery;
buttonset(methodName: 'destroy'): void;
buttonset(methodName: 'disable'): void;
buttonset(methodName: 'enable'): void;
buttonset(methodName: 'refresh'): void;
buttonset(methodName: 'widget'): JQuery;
buttonset(options: JQueryUI.ButtonOptions): JQuery;
buttonset(optionLiteral: string, optionName: string): any;
buttonset(optionLiteral: string, options: JQueryUI.ButtonOptions): any;
@@ -810,6 +831,17 @@ interface JQuery {
datepicker(): JQuery;
datepicker(methodName: string): JQuery;
datepicker(methodName: 'destroy'): void;
datepicker(methodName: 'dialog', date?: Date, onSelect?: () => void , pos?: any): void;
datepicker(methodName: 'dialog', date?: string, onSelect?: () => void , pos?: any): void;
datepicker(methodName: 'getDate'): Date;
datepicker(methodName: 'hide'): void;
datepicker(methodName: 'isDisabled'): boolean;
datepicker(methodName: 'refresh'): void;
datepicker(methodName: 'setDate', date: Date): void;
datepicker(methodName: 'setDate', date: string): void;
datepicker(methodName: 'show'): void;
datepicker(methodName: 'widget'): JQuery;
datepicker(options: JQueryUI.DatepickerOptions): JQuery;
datepicker(optionLiteral: string, optionName: string): any;
datepicker(optionLiteral: string, options: JQueryUI.DatepickerOptions): any;
@@ -817,6 +849,12 @@ interface JQuery {
dialog(): JQuery;
dialog(methodName: string): JQuery;
dialog(methodName: 'close'): void;
dialog(methodName: 'destroy'): void;
dialog(methodName: 'isOpen'): boolean;
dialog(methodName: 'moveToTop'): void;
dialog(methodName: 'open'): void;
dialog(methodName: 'widget'): JQuery;
dialog(options: JQueryUI.DialogOptions): JQuery;
dialog(optionLiteral: string, optionName: string): any;
dialog(optionLiteral: string, options: JQueryUI.DialogOptions): any;
@@ -824,6 +862,10 @@ interface JQuery {
draggable(): JQuery;
draggable(methodName: string): JQuery;
draggable(methodName: 'destroy'): void;
draggable(methodName: 'disable'): void;
draggable(methodName: 'enable'): void;
draggable(methodName: 'widget'): JQuery;
draggable(options: JQueryUI.DraggableOptions): JQuery;
draggable(optionLiteral: string, optionName: string): any;
draggable(optionLiteral: string, options: JQueryUI.DraggableOptions): any;
@@ -831,6 +873,10 @@ interface JQuery {
droppable(): JQuery;
droppable(methodName: string): JQuery;
droppable(methodName: 'destroy'): void;
droppable(methodName: 'disable'): void;
droppable(methodName: 'enable'): void;
droppable(methodName: 'widget'): JQuery;
droppable(options: JQueryUI.DroppableOptions): JQuery;
droppable(optionLiteral: string, optionName: string): any;
droppable(optionLiteral: string, options: JQueryUI.DraggableOptions): any;
@@ -838,6 +884,23 @@ interface JQuery {
menu(): JQuery;
menu(methodName: string): JQuery;
menu(methodName: 'blur'): void;
menu(methodName: 'collapse', event?: JQueryEventObject): void;
menu(methodName: 'collapseAll', event?: JQueryEventObject, all?: boolean): void;
menu(methodName: 'destroy'): void;
menu(methodName: 'disable'): void;
menu(methodName: 'enable'): void;
menu(methodName: string, event: JQueryEventObject, item: JQuery): void;
menu(methodName: 'focus', event: JQueryEventObject, item: JQuery): void;
menu(methodName: 'isFirstItem'): boolean;
menu(methodName: 'isLastItem'): boolean;
menu(methodName: 'next', event?: JQueryEventObject): void;
menu(methodName: 'nextPage', event?: JQueryEventObject): void;
menu(methodName: 'previous', event?: JQueryEventObject): void;
menu(methodName: 'previousPage', event?: JQueryEventObject): void;
menu(methodName: 'refresh'): void;
menu(methodName: 'select', event?: JQueryEventObject): void;
menu(methodName: 'widget'): JQuery;
menu(options: JQueryUI.MenuOptions): JQuery;
menu(optionLiteral: string, optionName: string): any;
menu(optionLiteral: string, options: JQueryUI.MenuOptions): any;
@@ -845,6 +908,15 @@ interface JQuery {
progressbar(): JQuery;
progressbar(methodName: string): JQuery;
progressbar(methodName: 'destroy'): void;
progressbar(methodName: 'disable'): void;
progressbar(methodName: 'enable'): void;
progressbar(methodName: 'refresh'): void;
progressbar(methodName: 'value'): number;
progressbar(methodName: 'value'): boolean;
progressbar(methodName: 'value', value: number): void;
progressbar(methodName: 'value', value: boolean): void;
progressbar(methodName: 'widget'): JQuery;
progressbar(options: JQueryUI.ProgressbarOptions): JQuery;
progressbar(optionLiteral: string, optionName: string): any;
progressbar(optionLiteral: string, options: JQueryUI.ProgressbarOptions): any;
@@ -852,6 +924,10 @@ interface JQuery {
resizable(): JQuery;
resizable(methodName: string): JQuery;
resizable(methodName: 'destroy'): void;
resizable(methodName: 'disable'): void;
resizable(methodName: 'enable'): void;
resizable(methodName: 'widget'): JQuery;
resizable(options: JQueryUI.ResizableOptions): JQuery;
resizable(optionLiteral: string, optionName: string): any;
resizable(optionLiteral: string, options: JQueryUI.ResizableOptions): any;
@@ -859,6 +935,10 @@ interface JQuery {
selectable(): JQuery;
selectable(methodName: string): JQuery;
selectable(methodName: 'destroy'): void;
selectable(methodName: 'disable'): void;
selectable(methodName: 'enable'): void;
selectable(methodName: 'widget'): JQuery;
selectable(options: JQueryUI.SelectableOptions): JQuery;
selectable(optionLiteral: string, optionName: string): any;
selectable(optionLiteral: string, options: JQueryUI.SelectableOptions): any;
@@ -866,6 +946,18 @@ interface JQuery {
slider(): JQuery;
slider(methodName: string): JQuery;
slider(methodName: 'destroy'): void;
slider(methodName: 'disable'): void;
slider(methodName: 'enable'): void;
slider(methodName: 'refresh'): void;
slider(methodName: 'value'): number;
slider(methodName: 'value', value: number): void;
slider(methodName: 'values'): Array<number>;
slider(methodName: 'values', index: number): number;
slider(methodName: string, index: number, value: number): void;
slider(methodName: 'values', index: number, value: number): void;
slider(methodName: 'values', values: Array<number>): void;
slider(methodName: 'widget'): JQuery;
slider(options: JQueryUI.SliderOptions): JQuery;
slider(optionLiteral: string, optionName: string): any;
slider(optionLiteral: string, options: JQueryUI.SliderOptions): any;
@@ -873,6 +965,10 @@ interface JQuery {
sortable(): JQuery;
sortable(methodName: string): JQuery;
sortable(methodName: 'destroy'): void;
sortable(methodName: 'disable'): void;
sortable(methodName: 'enable'): void;
sortable(methodName: 'widget'): JQuery;
sortable(options: JQueryUI.SortableOptions): JQuery;
sortable(optionLiteral: string, optionName: string): any;
sortable(optionLiteral: string, options: JQueryUI.SortableOptions): any;
@@ -880,6 +976,16 @@ interface JQuery {
spinner(): JQuery;
spinner(methodName: string): JQuery;
spinner(methodName: 'destroy'): void;
spinner(methodName: 'disable'): void;
spinner(methodName: 'enable'): void;
spinner(methodName: 'pageDown', pages?: number): void;
spinner(methodName: 'pageUp', pages?: number): void;
spinner(methodName: 'stepDown', steps?: number): void;
spinner(methodName: 'stepUp', steps?: number): void;
spinner(methodName: 'value'): number;
spinner(methodName: 'value', value: number): void;
spinner(methodName: 'widget'): JQuery;
spinner(options: JQueryUI.SpinnerOptions): JQuery;
spinner(optionLiteral: string, optionName: string): any;
spinner(optionLiteral: string, options: JQueryUI.SpinnerOptions): any;
@@ -887,6 +993,12 @@ interface JQuery {
tabs(): JQuery;
tabs(methodName: string): JQuery;
tabs(methodName: 'destroy'): void;
tabs(methodName: 'disable'): void;
tabs(methodName: 'enable'): void;
tabs(methodName: 'load', index: number): void;
tabs(methodName: 'refresh'): void;
tabs(methodName: 'widget'): JQuery;
tabs(options: JQueryUI.TabsOptions): JQuery;
tabs(optionLiteral: string, optionName: string): any;
tabs(optionLiteral: string, options: JQueryUI.TabsOptions): any;
@@ -894,6 +1006,12 @@ interface JQuery {
tooltip(): JQuery;
tooltip(methodName: string): JQuery;
tooltip(methodName: 'destroy'): void;
tooltip(methodName: 'disable'): void;
tooltip(methodName: 'enable'): void;
tooltip(methodName: 'open'): void;
tooltip(methodName: 'close'): void;
tooltip(methodName: 'widget'): JQuery;
tooltip(options: JQueryUI.TooltipOptions): JQuery;
tooltip(optionLiteral: string, optionName: string): any;
tooltip(optionLiteral: string, options: JQueryUI.TooltipOptions): any;
leaflet/leaflet.d.ts
Vendored
+545 -545
View File
File diff suppressed because it is too large Load Diff
mousetrap/mousetrap.d.ts
Vendored
+2 -2
View File
@@ -4,11 +4,11 @@
// Definitions: https://github.com/borisyankov/DefinitelyTyped
interface ExtendedKeyboardEvent extends KeyboardEvent {
returnValue: bool; // IE returnValue
returnValue: boolean; // IE returnValue
}
interface MousetrapStatic {
stopCallback: (e: ExtendedKeyboardEvent, element: Element, combo: string) => bool;
stopCallback: (e: ExtendedKeyboardEvent, element: Element, combo: string) => boolean;
bind(keys: string, callback: (e: ExtendedKeyboardEvent, combo: string) => any, action?: string): void;
bind(keyArray: string[], callback: (e: ExtendedKeyboardEvent, combo: string) => any, action?: string): void;
rx.js/rx.js.aggregates.d.ts
Vendored
+11 -8
View File
@@ -1,16 +1,19 @@
///<reference path="rx.js.d.ts" />
// Type definitions for RxJS "Aggregates"
// Project: http://rx.codeplex.com/
// Definitions by: Carl de Billy <http://carl.debilly.net/>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
///<reference path="rx.js.d.ts" />
declare module Rx {
export module Observable {
function all(predicate?: (any) => bool): IObservable;
function min(predicate?: (any) => bool): IObservable;
function max(predicate?: (any) => bool): IObservable;
function count(predicate?: (any) => bool): IObservable;
function sum(keySelector?: (any) => any): IObservable;
interface IObservable<T> {
all(predicate?: (value: T) => bool): IObservable<bool>;
min(comparer?: (value1: T, value2: T) => number): IObservable<T>;
max(comparer?: (value1: T, value2: T) => number): IObservable<number>;
count(predicate?: (item: T) => bool): IObservable<number>;
sum(keySelector?: (item: T) => number): IObservable<number>;
isEmpty(predicate?: (value: T) => bool): IObservable<bool>;
contains(value: T, comparer?: (value1: T, value2: T) => bool): IObservable<bool>;
average(keySelector?: (item: T) => number): IObservable<number>;
}
}
rx.js/rx.js.d.ts
Vendored
+395 -399
View File
@@ -5,462 +5,458 @@
declare module Rx {
export module Internals {
function inherits(child: Function, parent: Function): Function;
function addProperties(obj: Object, ...sourcces: Object[]): void;
function addRef(xs: IObservable, r: { getDisposable(): _IDisposable; }): IObservable;
}
export module Internals {
function inherits(child: Function, parent: Function): Function;
function addProperties(obj: Object, ...sourcces: Object[]): void;
function addRef<T>(xs: IObservable<T>, r: { getDisposable(): _IDisposable; }): IObservable<T>;
}
//Collections
interface IIndexedItem {
id: number;
value: IScheduledItem;
//Collections
interface IIndexedItem {
id: number;
value: IScheduledItem;
compareTo(other: IIndexedItem): number;
}
compareTo(other: IIndexedItem): number;
}
// Priority Queue for Scheduling
interface IPriorityQueue {
items: IIndexedItem[];
length: number;
// Priority Queue for Scheduling
interface IPriorityQueue {
items: IIndexedItem[];
length: number;
isHigherPriority(left: number, right: number): bool;
percolate(index: number): void;
heapify(index: number): void;
peek(): IIndexedItem;
removeAt(index: number): void;
dequeue(): IIndexedItem;
enqueue(item: IIndexedItem): void;
remove(item: IIndexedItem): bool;
}
isHigherPriority(left: number, right: number): bool;
percolate(index: number): void;
heapify(index: number): void;
peek(): IIndexedItem;
removeAt(index: number): void;
dequeue(): IIndexedItem;
enqueue(item: IIndexedItem): void;
remove(item: IIndexedItem): bool;
}
interface _IDisposable {
dispose(): void;
}
interface _IDisposable {
dispose(): void;
}
interface ICompositeDisposable {
disposables: _IDisposable[];
isDisposed: bool;
length: number;
export class CompositeDisposable {
constructor (...disposables: _IDisposable[]);
dispose(): void;
add(item: _IDisposable): void;
remove(item: _IDisposable): bool;
clear(): void;
contains(item: _IDisposable): bool;
toArray(): _IDisposable[];
}
export interface CompositeDisposable {
(...disposables: _IDisposable[]): ICompositeDisposable;
}
disposables: _IDisposable[];
isDisposed: bool;
length: number;
// Main disposable class
interface IDisposable {
isDisposed: bool;
action: () =>void;
dispose(): void;
add(item: _IDisposable): void;
remove(item: _IDisposable): bool;
clear(): void;
contains(item: _IDisposable): bool;
toArray(): _IDisposable[];
}
dispose(): void;
}
export interface Disposable {
(action: () =>void ): IDisposable;
// Main disposable class
interface IDisposable {
isDisposed: bool;
action: () =>void;
create(action: () =>void ): _IDisposable;
empty: _IDisposable;
}
dispose(): void;
}
export interface Disposable {
(action: () =>void ): IDisposable;
// Single assignment
interface ISingleAssignmentDisposable {
isDisposed: bool;
current: _IDisposable;
create(action: () =>void ): _IDisposable;
empty: _IDisposable;
}
dispose(): void;
disposable(value?: _IDisposable): _IDisposable;
getDisposable(): _IDisposable;
setDisposable(value: _IDisposable): void;
}
export interface SingleAssignmentDisposable {
(): ISingleAssignmentDisposable;
}
// Single assignment
interface ISingleAssignmentDisposable {
isDisposed: bool;
current: _IDisposable;
// Multiple assignment disposable
interface ISerialDisposable {
isDisposed: bool;
current: _IDisposable;
dispose(): void;
disposable(value?: _IDisposable): _IDisposable;
getDisposable(): _IDisposable;
setDisposable(value: _IDisposable): void;
}
export interface SingleAssignmentDisposable {
(): ISingleAssignmentDisposable;
}
dispose(): void;
getDisposable(): _IDisposable;
setDisposable(value: _IDisposable): void;
disposable(value?: _IDisposable): _IDisposable;
}
export interface SerialDisposable {
(): ISerialDisposable;
}
// Multiple assignment disposable
export class SerialDisposable {
isDisposed: bool;
current: _IDisposable;
interface IRefCountDisposable {
underlyingDisposable: _IDisposable;
isDisposed: bool;
isPrimaryDisposed: bool;
count: number;
dispose(): void;
getDisposable(): _IDisposable;
setDisposable(value: _IDisposable): void;
disposable(value?: _IDisposable): _IDisposable;
}
dispose(): void;
getDisposable(): _IDisposable;
}
export interface RefCountDisposable {
(disposable: _IDisposable): IRefCountDisposable;
}
export class RefCountDisposable {
constructor(disposable: _IDisposable);
interface IScheduledItem {
scheduler: IScheduler;
state: any;
action: (scheduler: IScheduler, state) => _IDisposable;
dueTime: number;
comparer: (x: number, y: number) =>number;
disposable: ISingleAssignmentDisposable;
underlyingDisposable: _IDisposable;
isDisposed: bool;
isPrimaryDisposed: bool;
count: number;
invoke(): void;
compareTo(other: IScheduledItem): number;
isCancelled(): bool;
invokeCore(): _IDisposable;
}
dispose(): void;
getDisposable(): _IDisposable;
}
interface IScheduler {
_schedule: (state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable) => _IDisposable;
_scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable;
_scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable;
interface IScheduledItem {
scheduler: IScheduler;
state: any;
action: (scheduler: IScheduler, state) => _IDisposable;
dueTime: number;
comparer: (x: number, y: number) =>number;
disposable: ISingleAssignmentDisposable;
now(): number;
scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
invoke(): void;
compareTo(other: IScheduledItem): number;
isCancelled(): bool;
invokeCore(): _IDisposable;
}
catchException(handler: (exception: any) =>bool): ICatchScheduler;
schedulePeriodic(period: number, action: () =>void ): _IDisposable;
schedulePeriodicWithState(state: any, period: number, action: (state: any) =>any): _IDisposable;//returns {Disposable|SingleAssignmentDisposable}
schedule(action: () =>void ): _IDisposable;
scheduleWithRelative(dueTime: number, action: () =>void ): _IDisposable;
scheduleWithAbsolute(dueTime: number, action: () =>void ): _IDisposable;
scheduleRecursive(action: (action: () =>void ) =>void ): _IDisposable;
scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) =>void ) =>void ): _IDisposable;
scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): _IDisposable;
scheduleRecursiveWithRelativeAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) =>void ) =>void ): _IDisposable;
scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): _IDisposable;
scheduleRecursiveWithAbsoluteAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) =>void ) =>void ): _IDisposable;
}
export interface Scheduler {
(now: () =>number,
schedule: (state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable) => _IDisposable,
scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable,
scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable
): IScheduler;
interface IScheduler {
_schedule: (state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable) => _IDisposable;
_scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable;
_scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable;
now(): number;
normalize(timeSpan: number): number;
now(): number;
scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
immediate: IScheduler;
currentThread: ICurrentScheduler;//IScheduler;
timeout: IScheduler;
}
catchException(handler: (exception: any) =>bool): ICatchScheduler;
schedulePeriodic(period: number, action: () =>void ): _IDisposable;
schedulePeriodicWithState(state: any, period: number, action: (state: any) =>any): _IDisposable;//returns {Disposable|SingleAssignmentDisposable}
schedule(action: () =>void ): _IDisposable;
scheduleWithRelative(dueTime: number, action: () =>void ): _IDisposable;
scheduleWithAbsolute(dueTime: number, action: () =>void ): _IDisposable;
scheduleRecursive(action: (action: () =>void ) =>void ): _IDisposable;
scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) =>void ) =>void ): _IDisposable;
scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): _IDisposable;
scheduleRecursiveWithRelativeAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) =>void ) =>void ): _IDisposable;
scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): _IDisposable;
scheduleRecursiveWithAbsoluteAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) =>void ) =>void ): _IDisposable;
}
export interface Scheduler {
(now: () =>number,
schedule: (state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable) => _IDisposable,
scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable,
scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable
): IScheduler;
// Current Thread IScheduler
interface ICurrentScheduler extends IScheduler {
scheduleRequired(): bool;
ensureTrampoline(action: () =>_IDisposable): _IDisposable;
}
now(): number;
normalize(timeSpan: number): number;
// Virtual IScheduler
interface IVirtualTimeScheduler extends IScheduler {
toRelative(duetime): number;
toDateTimeOffset(duetime: number): number;
immediate: IScheduler;
currentThread: ICurrentScheduler;//IScheduler;
timeout: IScheduler;
}
clock: number;
comparer: (x: number, y: number) =>number;
isEnabled: bool;
queue: IPriorityQueue;
scheduleRelativeWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
scheduleRelative(dueTime: number, action: () =>void ): _IDisposable;
start(): _IDisposable;
stop(): void;
advanceTo(time: number);
advanceBy(time: number);
sleep(time: number);
getNext(): IScheduledItem;
scheduleAbsolute(dueTime: number, action: () =>void );
scheduleAbsoluteWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
}
//export module VirtualTimeScheduler {
// //absract
// function new (initialClock: number, comparer: (x: number, y: number) =>number): IVirtualTimeScheduler;
//}
// Current Thread IScheduler
interface ICurrentScheduler extends IScheduler {
scheduleRequired(): bool;
ensureTrampoline(action: () =>_IDisposable): _IDisposable;
}
// Virtual IScheduler
interface IVirtualTimeScheduler extends IScheduler {
toRelative(duetime): number;
toDateTimeOffset(duetime: number): number;
clock: number;
comparer: (x: number, y: number) =>number;
isEnabled: bool;
queue: IPriorityQueue;
scheduleRelativeWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
scheduleRelative(dueTime: number, action: () =>void ): _IDisposable;
start(): _IDisposable;
stop(): void;
advanceTo(time: number);
advanceBy(time: number);
sleep(time: number);
getNext(): IScheduledItem;
scheduleAbsolute(dueTime: number, action: () =>void );
scheduleAbsoluteWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
}
//export module VirtualTimeScheduler {
// //absract
// function new (initialClock: number, comparer: (x: number, y: number) =>number): IVirtualTimeScheduler;
//}
// CatchScheduler
interface ICatchScheduler extends IScheduler { }
// CatchScheduler
interface ICatchScheduler extends IScheduler { }
// Notifications
interface INotification {
accept(observer: IObserver): void;
accept(onNext: (value: any) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): void;
toObservable(scheduler?: IScheduler): IObservable;
hasValue: bool;
equals(other: INotification): bool;
kind: string;
value?: any;
exception?: any;
}
export interface Notification {
//abstract
//function new (): INotification;
// Notifications
interface INotification<T> {
accept(observer: IObserver<T>): void;
accept(onNext: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): void;
toObservable(scheduler?: IScheduler): IObservable;
hasValue: bool;
equals(other: INotification<T>): bool;
kind: string;
value?: T;
exception?: any;
}
export interface Notification {
//abstract
//function new (): INotification;
createOnNext(value: any): INotification;//ON
createOnError(exception): INotification;//OE
createOnCompleted(): INotification;//OC
}
createOnNext<T>(value: T): INotification<T>;//ON
createOnError<T>(exception): INotification<T>;//OE
createOnCompleted<T>(): INotification<T>;//OC
}
export module Internals {
// Enumerator
interface IEnumerator {
moveNext(): bool;
getCurrent(): any;
dispose(): void;
}
export interface Enumerator {
(moveNext: () =>bool, getCurrent: () => any, dispose: () =>void ): IEnumerator;
var Notification: Notification;
create(moveNext: () =>bool, getCurrent: () =>any, dispose?: () =>void ): IEnumerator;
}
export module Internals {
// Enumerator
interface IEnumerator<T> {
moveNext(): bool;
getCurrent(): T;
dispose(): void;
}
export interface Enumerator<T> {
(moveNext: () =>bool, getCurrent: () => T, dispose: () =>void ): IEnumerator<T>;
// Enumerable
interface IEnumerable {
getEnumerator(): IEnumerator;
create(moveNext: () =>bool, getCurrent: () => T, dispose?: () =>void ): IEnumerator<T>;
}
concat(): IObservable;
catchException(): IObservable;
}
export interface Enumerable {
(getEnumerator: () =>IEnumerator): IEnumerable;
// Enumerable
interface IEnumerable<T> {
getEnumerator(): IEnumerator<T>;
repeat(value: any, repeatCount?: number): IEnumerable;
forEach(source: any[], selector?: (element: any, index: number) =>any): IEnumerable;
forEach(source: { length: number;[index: number]: any; }, selector?: (element: any, index: number) =>any): IEnumerable;
}
}
concat(): IObservable<T>;
catchException(): IObservable<T>;
}
export interface Enumerable<T> {
(getEnumerator: () =>IEnumerator<T>): IEnumerable<T>;
// Observer
interface IObserver {
onNext(value: any): void;
onError(exception: any): void;
onCompleted(): void;
repeat(value: T, repeatCount?: number): IEnumerable;
forEach<T2>(source: T[], selector?: (element: T, index: number) => T2): IEnumerable<T2>;
forEach<T2>(source: { length: number; [index: number]: T; }, selector?: (element: T, index: number) => T2): IEnumerable<T2>;
}
}
toNotifier(): (notification: INotification) =>void;
asObserver(): IObserver;
checked(): ICheckedObserver;
}
export module Observer {
//abstract
//function new (): IObserver;
// Observer
interface IObserver<T> {
onNext(value: T): void;
onError(exception: any): void;
onCompleted(): void;
function create(onNext: (value: any) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObserver;
function fromNotifier(handler: (notification: INotification) =>void ): IObserver;
}
toNotifier(): (notification: INotification<T>) =>void;
asObserver(): IObserver<T>;
checked(): ICheckedObserver;
}
export module Observer {
//abstract
//function new (): IObserver;
export module Internals {
// Abstract Observer
interface IAbstractObserver extends IObserver {
isStopped: bool;
function create<T>(onNext: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObserver<T>;
function fromNotifier<T>(handler: (notification: INotification<T>) =>void ): IObserver<T>;
}
dispose(): void;
next(value: any): void;
error(exception: any): void;
completed(): void;
fail(): bool;
}
//export module AbstractObserver {
// //abstract
// function new (): IAbstractObserver;
//}
}
export module Internals {
// Abstract Observer
interface IAbstractObserver<T> extends IObserver<T> {
isStopped: bool;
interface IAnonymousObserver extends Internals.IAbstractObserver {
_onNext: (value: any) =>void;
_onError: (exception: any) =>void;
_onCompleted: () =>void;
}
export interface AnonymousObserver {
(onNext: (value: any) =>void , onError: (exception: any) =>void , onCompleted: () =>void ): IAnonymousObserver;
}
dispose(): void;
next(value: T): void;
error(exception: any): void;
completed(): void;
fail(): bool;
}
//export module AbstractObserver {
// //abstract
// function new (): IAbstractObserver;
//}
}
interface ICheckedObserver extends IObserver {
_observer: IObserver;
_state: number; // 0 - idle, 1 - busy, 2 - done
checkAccess(): void;
}
export class AnonymousObserver<T> {
constructor(onNext: (value: T) => void , onError: (exception: any) => void , onCompleted: () => void);
}
export module Internals {
interface IScheduledObserver extends IAbstractObserver {
scheduler: IScheduler;
observer: IObserver;
isAcquired: bool;
hasFaulted: bool;
//queue: { (value: any): void; (exception: any): void; (): void; }[];
disposable: ISerialDisposable;
interface ICheckedObserver<T> extends IObserver<T> {
_observer: IObserver<T>;
_state: number; // 0 - idle, 1 - busy, 2 - done
checkAccess(): void;
}
ensureActive(): void;
}
export interface ScheduledObserver {
(scheduler: IScheduler, observer: IObserver): IScheduledObserver;
}
}
export module Internals {
interface IScheduledObserver<T> extends IAbstractObserver<T> {
scheduler: IScheduler;
observer: IObserver<T>;
isAcquired: bool;
hasFaulted: bool;
//queue: { (value: any): void; (exception: any): void; (): void; }[];
disposable: SerialDisposable;
ensureActive(): void;
}
export interface ScheduledObserver<T> {
(scheduler: IScheduler, observer: IObserver<T>): IScheduledObserver<T>;
}
}
interface IObservable {
_subscribe: (observer: IObserver) =>_IDisposable;
interface IObservable<T> {
_subscribe: (observer: IObserver<T>) =>_IDisposable;
subscribe(observer: IObserver): _IDisposable;
subscribe(observer: IObserver<T>): _IDisposable;
finalValue(): IObservable;
subscribe(onNext?: (value: any) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): _IDisposable;
toArray(): IObservable;
finalValue(): IObservable<T>;
subscribe(onNext?: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): _IDisposable;
toArray(): IObservable<T>;
observeOn(scheduler: IScheduler): IObservable;
subscribeOn(scheduler: IScheduler): IObservable;
amb(rightSource: IObservable): IObservable;
catchException(handler: (exception: any) =>IObservable): IObservable;
catchException(second: IObservable): IObservable;
combineLatest(second: IObservable, resultSelector: (v1: any, v2: any) =>any): IObservable;
combineLatest(second: IObservable, third: IObservable, resultSelector: (v1: any, v2: any, v3: any) =>any): IObservable;
combineLatest(second: IObservable, third: IObservable, fourth: IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any) =>any): IObservable;
combineLatest(second: IObservable, third: IObservable, fourth: IObservable, fifth, IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any, v5: any) =>any): IObservable;
combineLatest(...soucesAndResultSelector: any[]): IObservable;
concat(...sources: IObservable[]): IObservable;
concat(sources: IObservable[]): IObservable;
concatIObservable(): IObservable;
merge(maxConcurrent: number): IObservable;
merge(other: IObservable): IObservable;
mergeIObservable(): IObservable;
onErrorResumeNext(second: IObservable): IObservable;
skipUntil(other: IObservable): IObservable;
switchLatest(): IObservable;
takeUntil(other: IObservable): IObservable;
zip(second: IObservable, resultSelector: (v1: any, v2: any) =>any): IObservable;
zip(second: IObservable, third: IObservable, resultSelector: (v1: any, v2: any, v3: any) =>any): IObservable;
zip(second: IObservable, third: IObservable, fourth: IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any) =>any): IObservable;
zip(second: IObservable, third: IObservable, fourth: IObservable, fifth, IObservable, resultSelector: (v1: any, v2: any, v3: any, v4: any, v5: any) =>any): IObservable;
zip(...soucesAndResultSelector: any[]): IObservable;
zip(second: any[], resultSelector: (left: any, right: any) =>any): IObservable;
asIObservable(): IObservable;
bufferWithCount(count: number, skip?: number): IObservable;
dematerialize(): IObservable;
distinctUntilChanged(keySelector?: (value: any) =>any, comparer?: (x: any, y: any) =>bool): IObservable;
doAction(observer: IObserver): IObservable;
doAction(onNext: (value: any) => void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObservable;
finallyAction(action: () =>void ): IObservable;
ignoreElements(): IObservable;
materialize(): IObservable;
repeat(repeatCount?: number): IObservable;
retry(retryCount?: number): IObservable;
scan(seed: any, accumulator: (acc: any, value: any) =>any): IObservable;
scan(accumulator: (acc: any, value: any) =>any): IObservable;
skipLast(count: number): IObservable;
startWith(...values: any[]): IObservable;
startWith(scheduler: IScheduler, ...values: any[]): IObservable;
takeLast(count: number, scheduler?: IScheduler): IObservable;
takeLastBuffer(count: number): IObservable;
windowWithCount(count: number, skip?: number): IObservable;
defaultIfEmpty(defaultValue?: any): IObservable;
distinct(keySelector?: (value: any) =>any, keySerializer?: (key: any) =>string): IObservable;
groupBy(keySelector: (value: any) =>any, elementSelector?: (value: any) =>any, keySerializer?: (key: any) =>string): IGroupedObservable;
groupByUntil(keySelector: (value: any) =>any, elementSelector: (value: any) =>any, durationSelector: (gloup: IGroupedObservable) =>IObservable, keySerializer?: (key: any) =>string): IGroupedObservable;
select(selector: (value: any, index: number) =>any): IObservable;
selectMany(selector: (value: any) =>IObservable, resultSelector?: (x: any, y: any) =>any): IObservable;
selectMany(other: IObservable): IObservable;
skip(count: number): IObservable;
skipWhile(predicate: (value: any, index?: number) =>bool): IObservable;
take(count: number, scheduler?: IScheduler): IObservable;
takeWhile(predicate: (value: any, index?: number) =>bool): IObservable;
where(predicate: (value: any, index?: number) => bool): IObservable;
observeOn(scheduler: IScheduler): IObservable<T>;
subscribeOn(scheduler: IScheduler): IObservable<T>;
amb(rightSource: IObservable<T>): IObservable<T>;
catchException(handler: (exception: any) =>IObservable<T>): IObservable<T>;
catchException(second: IObservable<T>): IObservable<T>;
combineLatest<T2, TResult>(second: IObservable<T2>, resultSelector: (v1: T, v2: T2) =>TResult): IObservable<TResult>;
combineLatest<T2, T3, TResult>(second: IObservable<T2>, third: IObservable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) =>TResult): IObservable<TResult>;
combineLatest<T2, T3, T4, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) =>TResult): IObservable<TResult>;
combineLatest<T2, T3, T4, T5, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, fifth: IObservable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) =>TResult): IObservable<TResult>;
combineLatest<TResult>(...soucesAndResultSelector: any[]): IObservable<TResult>;
concat(...sources: IObservable<T>[]): IObservable<T>;
concat(sources: IObservable<T>[]): IObservable<T>;
//concatIObservable(): IObservable<T>;
merge(maxConcurrent: number): IObservable<T>;
merge(other: IObservable<T>): IObservable<T>;
//mergeIObservable(): IObservable;
onErrorResumeNext(second: IObservable<T>): IObservable<T>;
skipUntil<T2>(other: IObservable<T2>): IObservable<T>;
switchLatest(): IObservable<T>;
takeUntil<T2>(other: IObservable<T2>): IObservable<T>;
zip<T2, TResult>(second: IObservable<T2>, resultSelector: (v1: T, v2: T2) =>TResult): IObservable<TResult>;
zip<T2, T3, TResult>(second: IObservable<T2>, third: IObservable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): IObservable<TResult>;
zip<T2, T3, T4, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): IObservable<TResult>;
zip<T2, T3, T4, T5, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, fifth: IObservable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): IObservable<TResult>;
zip<TResult>(...soucesAndResultSelector: any[]): IObservable<TResult>;
zip<TResult>(second: any[], resultSelector: (left: T, right: any) => TResult): IObservable<TResult>;
asIObservable(): IObservable;
bufferWithCount(count: number, skip?: number): IObservable<T>;
dematerialize<TOrigin>(): IObservable<TOrigin>;
distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) =>bool): IObservable;
doAction(observer: IObserver<T>): IObservable<T>;
doAction(onNext: (value: T) => void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObservable<T>;
finallyAction(action: () =>void): IObservable<T>;
ignoreElements(): IObservable<T>;
materialize(): IObservable<INotification<any>>; // IObservable<INotification<T>> not supported by TypeScript 0.9.0 !!
repeat(repeatCount?: number): IObservable<T>;
retry(retryCount?: number): IObservable<T>;
scan<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
scan<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
skipLast(count: number): IObservable<T>;
startWith(...values: T[]): IObservable<T>;
startWith(scheduler: IScheduler, ...values: T[]): IObservable<T>;
takeLast(count: number, scheduler?: IScheduler): IObservable<T>;
takeLastBuffer(count: number): IObservable<T>;
windowWithCount(count: number, skip?: number): IObservable<T>;
defaultIfEmpty(defaultValue?: any): IObservable<T>;
distinct<TKey>(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) =>string): IObservable<T>;
groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector?: (value: T) => TElement, keySerializer?: (key: TKey) => string): IGroupedObservable<TKey, TElement>;
groupByUntil<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: IGroupedObservable<TKey, TElement>) => IObservable<number>, keySerializer?: (key: TKey) => string): IGroupedObservable<TKey, TElement>;
select<T2>(selector: (value: T, index: number) =>T2): IObservable<T2>;
selectMany<T2>(selector: (value: T) =>IObservable<T2>, resultSelector?: (x: any, y: any) =>any): IObservable<T2>;
selectMany<T2>(other: IObservable<T2>): IObservable<T2>;
skip(count: number): IObservable<T>;
skipWhile(predicate: (value: T, index?: number) =>bool): IObservable<T>;
take(count: number, scheduler?: IScheduler): IObservable<T>;
takeWhile(predicate: (value: T, index?: number) =>bool): IObservable<T>;
where(predicate: (value: T, index?: number) => bool): IObservable<T>;
// time
delay(dueTime: number, scheduler?: IScheduler): IObservable;
throttle(dueTime: number, scheduler?: IScheduler): IObservable;
windowWithTime(dueTime: number, timeShiftOrScheduler?: any, scheduler?: IScheduler): IObservable;
timeInterval(scheduler: IScheduler): IObservable;
sample(interval: number, scheduler?: IScheduler): IObservable;
sample(sampler: IObservable, scheduler?: IScheduler): IObservable;
timeout(dueTime: number, other?: IObservable, scheduler?: IScheduler): IObservable;
delaySubscription(dueTime: number, scheduler?: IScheduler): IObservable;
}
export interface Observable {
(subscribe: (observer: IObserver) =>_IDisposable): IObservable;
// time
delay(dueTime: number, scheduler?: IScheduler): IObservable<T>;
throttle(dueTime: number, scheduler?: IScheduler): IObservable<T>;
windowWithTime(dueTime: number, timeShiftOrScheduler?: any, scheduler?: IScheduler): IObservable<T>;
timeInterval(scheduler: IScheduler): IObservable<T>;
sample(interval: number, scheduler?: IScheduler): IObservable<T>;
sample<TSample>(sampler: IObservable<TSample>, scheduler?: IScheduler): IObservable<T>;
timeout(dueTime: number, other?: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
delaySubscription(dueTime: number, scheduler?: IScheduler): IObservable<T>;
}
start(func: () =>any, scheduler?: IScheduler, context?: any): IObservable;
toAsync(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => IObservable;
create(subscribe: (Observer) =>() =>void ): IObservable;
createWithDisposable(subscribe: (Observer) =>_IDisposable): IObservable;
defer(observableFactory: () =>IObservable): IObservable;
empty(scheduler?: IScheduler): IObservable;
fromArray(array: any[], scheduler?: IScheduler): IObservable;
fromArray(array: { length: number;[index: number]: any; }, scheduler?: IScheduler): IObservable;
generate(initialState: any, condition: (state: any) =>bool, iterate: (state: any) =>any, resultSelector: (state: any) =>any, scheduler?: IScheduler): IObservable;
never(): IObservable;
range(start: number, count: number, scheduler?: IScheduler): IObservable;
repeat(value: any, repeatCount?: number, scheduler?: IScheduler): IObservable;
returnValue(value: any, scheduler?: IScheduler): IObservable;
throwException(exception: any, scheduler?: IScheduler): IObservable;
using(resourceFactory: () =>any, observableFactory: (resource: any) =>IObservable): IObservable;
amb(...sources: IObservable[]): IObservable;
catchException(sources: IObservable[]): IObservable;
catchException(...sources: IObservable[]): IObservable;
concat(...sources: IObservable[]): IObservable;
concat(sources: IObservable[]): IObservable;
merge(...sources: IObservable[]): IObservable;
merge(sources: IObservable[]): IObservable;
merge(scheduler: IScheduler, ...sources: IObservable[]): IObservable;
merge(scheduler: IScheduler, sources: IObservable[]): IObservable;
onErrorResumeNext(...sources: IObservable[]): IObservable;
onErrorResumeNext(sources: IObservable[]): IObservable;
}
interface Observable {
(subscribe: (observer: IObserver<any>) =>_IDisposable): IObservable;
export module Internals {
interface IAnonymousObservable extends IObservable { }
export interface AnonymousObservable {
(subscribe: (observer: IObserver) =>_IDisposable): IAnonymousObservable;
}
}
start<T>(func: () =>T, scheduler?: IScheduler, context?: any): IObservable<T>;
toAsync<T>(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => IObservable<T>;
create<T>(subscribe: (observer: IObserver<T>) => void ): IObservable<T>;
create<T>(subscribe: (observer: IObserver<T>) => () => void ): IObservable<T>;
createWithDisposable<T>(subscribe: (observer: IObserver<T>) =>_IDisposable): IObservable<T>;
defer<T>(observableFactory: () =>IObservable<T>): IObservable<T>;
empty<T>(scheduler?: IScheduler): IObservable<T>;
fromArray<T>(array: T[], scheduler?: IScheduler): IObservable<T>;
fromArray<T>(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): IObservable<T>;
generate<TState, TResult>(initialState: TState, condition: (state: TState) => bool, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): IObservable<TResult>;
never<T>(): IObservable<T>;
range(start: number, count: number, scheduler?: IScheduler): IObservable<number>;
repeat<T>(value: T, repeatCount?: number, scheduler?: IScheduler): IObservable<T>;
returnValue<T>(value: T, scheduler?: IScheduler): IObservable<T>;
throwException<T>(exception: any, scheduler?: IScheduler): IObservable<T>;
using<TSource, TResource>(resourceFactory: () => TResource, observableFactory: (resource: TResource) => IObservable<TSource>): IObservable<TSource>;
amb<T>(...sources: IObservable<T>[]): IObservable<T>;
catchException<T>(sources: IObservable<T>[]): IObservable<T>;
catchException<T>(...sources: IObservable<T>[]): IObservable<T>;
concat<T>(...sources: IObservable<T>[]): IObservable<T>;
concat<T>(sources: IObservable<T>[]): IObservable<T>;
merge<T>(...sources: IObservable<T>[]): IObservable<T>;
merge<T>(sources: IObservable<T>[]): IObservable<T>;
merge<T>(scheduler: IScheduler, ...sources: IObservable<T>[]): IObservable<T>;
merge<T>(scheduler: IScheduler, sources: IObservable<T>[]): IObservable<T>;
onErrorResumeNext<T>(...sources: IObservable<T>[]): IObservable<T>;
onErrorResumeNext<T>(sources: IObservable<T>[]): IObservable<T>;
}
interface IGroupedObservable extends IObservable {
key: any;
underlyingObservable: IObservable;
}
var Observable: Observable;
interface ISubject extends IObservable, IObserver {
isDisposed: bool;
isStopped: bool;
observers: IObserver[];
export module Internals {
interface IAnonymousObservable<T> extends IObservable<T> { }
export interface AnonymousObservable<T> {
(subscribe: (observer: IObserver<T>) =>_IDisposable): IAnonymousObservable<T>;
}
}
dispose(): void;
}
export interface Subject {
(): ISubject;
interface IGroupedObservable<TKey, TElement> extends IObservable<TElement> {
key: TKey;
underlyingObservable: IObservable<TElement>;
}
create(observer: IObserver, observable: IObservable): ISubject;
}
interface ISubject<T> extends IObservable<T>, IObserver<T> {
isDisposed: bool;
isStopped: bool;
//observers: IObserver<T>[];
interface IAsyncSubject extends IObservable, IObserver {
isDisposed: bool;
value: any;
hasValue: bool;
observers: IObserver[];
exception: any;
dispose(): void;
}
dispose(): void;
}
export interface AsyncSubject {
(): IAsyncSubject;
}
export interface Subject {
(): ISubject<any>;
interface IAnonymousSubject extends IObservable {
onNext(value: any): void;
onError(exception: any): void;
onCompleted(): void;
}
create<T>(observer?: IObserver<T>, observable?: IObservable<T>): ISubject<T>;
}
interface IAsyncSubject<T> extends IObservable<T>, IObserver<T> {
isDisposed: bool;
value: T;
hasValue: bool;
observers: IObserver<T>[];
exception: any;
dispose(): void;
}
export interface AsyncSubject<T> {
(): IAsyncSubject<T>;
}
interface IAnonymousSubject<T> extends IObservable<T> {
onNext(value: T): void;
onError(exception: any): void;
onCompleted(): void;
}
}
rx.js/rx.js.html.d.ts
Vendored
+4 -4
View File
@@ -1,8 +1,8 @@
///<reference path="rx.js.d.ts"/>
///<reference path="rx.js.d.ts"/>
declare module Rx {
export module Observable {
function fromEvent(element: HTMLElement, eventName: string) : IObservable;
function fromEvent(document: HTMLDocument, eventName: string): IObservable;
interface Observable {
fromEvent<TEvent>(element: HTMLElement, eventName: string): IObservable<TEvent>;
fromEvent<TEvent>(document: HTMLDocument, eventName: string): IObservable<TEvent>;
}
}
rx.js/rx.js.jquery.d.ts
Vendored
+83 -39
View File
@@ -1,46 +1,90 @@
///<reference path="../jquery/jquery.d.ts"/>
///<reference path="../jquery/jquery.d.ts"/>
///<reference path="rx.js.d.ts"/>
declare module JQueryResults {
export interface eventBase{
bubbles: bool;
cancelable: bool;
type: string;
preventDefault(): void;
isDefaultPrevented(): bool;
stopPropagation(): void;
isPropagationStopped(): bool;
data: any;
originalEvent: any;
eventPhase: number;
}
export interface keyEvent extends eventBase {
key: number;
keyCode: number;
altKey: bool;
ctrlKey: bool;
shiftKey: bool;
char: string;
metaKey: bool;
}
export interface uiEvent extends eventBase{
target: any;
currentTarget: any;
}
export interface mouseEvent extends keyEvent{
clientX: number;
clientY: number;
screenX: number;
screenY: number;
offsetX: number;
offsetY: number;
pageX: number;
pageY: number;
which: number;
}
}
interface JQueryStatic {
ajaxAsObservable(settings: JQueryAjaxSettings): Rx.IObservable;
getAsObservable(url: string, data: any, dataType: string): Rx.IObservable;
getJSONAsObservable(url: string, data: any): Rx.IObservable;
getScriptAsObservable(url: string, data: any): Rx.IObservable;
postAsObservable(url: string, data: any, dataType: string): Rx.IObservable;
ajaxAsObservable<T>(settings: JQueryAjaxSettings): Rx.IObservable<T>;
getAsObservable<T>(url: string, data: any, dataType: string): Rx.IObservable<T>;
getJSONAsObservable<T>(url: string, data: any): Rx.IObservable<T>;
getScriptAsObservable<T>(url: string, data: any): Rx.IObservable<T>;
postAsObservable<T>(url: string, data: any, dataType: string): Rx.IObservable<T>;
}
interface JQuery {
changeAsObservable(eventData?: any): Rx.IObservable;
clickAsObservable(eventData?: any): Rx.IObservable;
dblclickAsObservable(eventData?: any): Rx.IObservable;
focusAsObservable(eventData?: any): Rx.IObservable;
focusinAsObservable(eventData?: any): Rx.IObservable;
focusoutAsObservable(eventData?: any): Rx.IObservable;
keydownAsObservable(eventData?: any): Rx.IObservable;
keyupAsObservable(eventData?: any): Rx.IObservable;
loadAsObservable(eventData?: any): Rx.IObservable;
mousedownAsObservable(eventData?: any): Rx.IObservable;
mouseenterAsObservable(eventData?: any): Rx.IObservable;
mouseleaveAsObservable(eventData?: any): Rx.IObservable;
mousemoveAsObservable(eventData?: any): Rx.IObservable;
mouseoutAsObservable(eventData?: any): Rx.IObservable;
mouseoverAsObservable(eventData?: any): Rx.IObservable;
mouseupAsObservable(eventData?: any): Rx.IObservable;
resizeAsObservable(eventData?: any): Rx.IObservable;
scrollAsObservable(eventData?: any): Rx.IObservable;
selectAsObservable(eventData?: any): Rx.IObservable;
submitAsObservable(eventData?: any): Rx.IObservable;
unloadAsObservable(eventData?: any): Rx.IObservable;
readyAsObservable(): Rx.IObservable;
hideAsObservable(duration: number): Rx.IObservable;
showAsObservable(duration: number): Rx.IObservable;
animateAsObservable(properties: any, duration: number, easing?: string): Rx.IObservable;
fadeInAsObservable(duration: number, easing?: string): Rx.IObservable;
fadeToAsObservable(duration: number, opacity: number, easing?: string): Rx.IObservable;
fadeOutAsObservable(duration: number, easing?: string): Rx.IObservable;
fadeToggleAsObservable(duration: number, easing?: string): Rx.IObservable;
slideDownAsObservable(duration: number): Rx.IObservable;
slideUpAsObservable(duration: number): Rx.IObservable;
slideToggleAsObservable(duration: number): Rx.IObservable;
toggleAsObservable(duration: number): Rx.IObservable;
changeAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
clickAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
dblclickAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
focusAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
focusinAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
focusoutAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
keydownAsObservable(eventData?: any): Rx.IObservable<JQueryResults.keyEvent>;
keyupAsObservable(eventData?: any): Rx.IObservable<JQueryResults.keyEvent>;
loadAsObservable(eventData?: any): Rx.IObservable<JQueryResults.uiEvent>;
mousedownAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
mouseenterAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
mouseleaveAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
mousemoveAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
mouseoutAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
mouseoverAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
mouseupAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
resizeAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
scrollAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
selectAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
submitAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
unloadAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
hideAsObservable(duration: number): Rx.IObservable<JQueryResults.eventBase>;
showAsObservable(duration: number): Rx.IObservable<JQueryResults.eventBase>;
readyAsObservable(): Rx.IObservable<any>;
animateAsObservable(properties: any, duration: number, easing?: string): Rx.IObservable<any>;
fadeInAsObservable(duration: number, easing?: string): Rx.IObservable<any>;
fadeToAsObservable(duration: number, opacity: number, easing?: string): Rx.IObservable<any>;
fadeOutAsObservable(duration: number, easing?: string): Rx.IObservable<any>;
fadeToggleAsObservable(duration: number, easing?: string): Rx.IObservable<any>;
slideDownAsObservable(duration: number): Rx.IObservable<any>;
slideUpAsObservable(duration: number): Rx.IObservable<any>;
slideToggleAsObservable(duration: number): Rx.IObservable<any>;
toggleAsObservable(duration: number): Rx.IObservable<any>;
}
rx.js/rx.js.time.d.ts
Vendored
+8 -5
View File
@@ -1,10 +1,13 @@
///<reference path="rx.js.d.ts" />
declare module Rx {
export module Observable {
function ifThen(condition: () => bool, thenSource: IObservable): IObservable;
function ifThen(condition: () => bool, thenSource: IObservable, elseSource: IObservable): IObservable;
function ifThen(condition: () => bool, thenSource: IObservable, scheduler: IScheduler): IObservable;
function interval(period: number, scheduler?: IScheduler): IObservable;
interface IObservable<T> {
ifThen(condition: () => bool, thenSource: IObservable<T>): IObservable<T>;
ifThen(condition: () => bool, thenSource: IObservable<T>, elseSource: IObservable<T>): IObservable<T>;
ifThen(condition: () => bool, thenSource: IObservable<T>, scheduler: IScheduler): IObservable<T>;
}
interface Observable {
interval(period: number, scheduler?: IScheduler): IObservable<number>;
interval(dutTime: number, period: number, scheduler?: IScheduler): IObservable<number>;
}
}
zeroclipboard/zeroclipboard.d.ts
Vendored
+3 -3
View File
@@ -10,7 +10,7 @@ declare class ZeroClipboard {
setText(newText: string);
setTitle(newTitle: string);
setSize(width: number, height: number);
setHandCursor(enabled: bool);
setHandCursor(enabled: boolean);
version: string;
moviePath: string;
trustedDomains: any;
@@ -18,7 +18,7 @@ declare class ZeroClipboard {
hoverClass: string;
activeClass: string;
resetBridge();
ready: bool;
ready: boolean;
reposition();
on(eventName, func);
addEventListener(eventName: string, func);
@@ -29,7 +29,7 @@ declare class ZeroClipboard {
unglue(elements: any);
static setDefaults(options: ZeroClipboardOptions);
static destroy();
static detectFlashSupport(): bool;
static detectFlashSupport(): boolean;
static dispatch(eventName: string, func);
}