From 8a8a3cf9bf08329f6e5fc5487b54fde5882fe3cf Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sun, 15 Dec 2013 11:49:09 +0400
Subject: [PATCH] Updated rx.js.aggregates.d.ts

---
 rx.js/rx.js.aggregates.d.ts | 60 +++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 32 deletions(-)

diff --git a/rx.js/rx.js.aggregates.d.ts b/rx.js/rx.js.aggregates.d.ts
index 1955bfe7f9..4b2ed300ba 100644
--- a/rx.js/rx.js.aggregates.d.ts
+++ b/rx.js/rx.js.aggregates.d.ts
@@ -3,51 +3,47 @@
 // Type definitions for RxJS-Aggregates package
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
+// Revision by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
-//
-// Dependencies:
-// -> rx.js
-// -> rx.aggregates.js
 
 declare module Rx {
 	export interface Observable<T> {
-		aggregate<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
+		aggregate(accumulator: (acc: T, value: T) => T): Observable<T>;
 		aggregate<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
 
-		any(): Observable<boolean>;
-		any(selector: (item: T) => boolean): Observable<boolean>;
+		any(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<boolean>;
+		some(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<boolean>;	// alias for any
 
-		isEmpty(predicate?: (value: T) => boolean): Observable<boolean>;
-		all(predicate?: (value: T) => boolean): Observable<boolean>;
-		contains(value: T, comparer?: (value1: T, value2: T) => boolean): Observable<boolean>;
-		count(predicate?: (item: T) => boolean): Observable<number>;
-		sum(keySelector?: (item: T) => number): Observable<number>;
-		minBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): Observable<T>;
+		isEmpty(): Observable<boolean>;
+		all(predicate?: (value: T) => boolean, thisArg?: any): Observable<boolean>;
+		every(predicate?: (value: T) => boolean, thisArg?: any): Observable<boolean>;	// alias for all
+		contains(value: T): Observable<boolean>;
+		contains<TOther>(value: TOther, comparer: (value1: T, value2: TOther) => boolean): Observable<boolean>;
+		count(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<number>;
+		sum(keySelector?: (value: T, index: number, source: Observable<T>) => number, thisArg?: any): Observable<number>;
+		minBy<TKey>(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable<T>;
+		minBy(keySelector: (item: T) => number): Observable<T>;
 		min(comparer?: (value1: T, value2: T) => number): Observable<T>;
-		maxBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): Observable<T>;
+		maxBy<TKey>(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable<T>;
+		maxBy(keySelector: (item: T) => number): Observable<T>;
 		max(comparer?: (value1: T, value2: T) => number): Observable<number>;
-		average(keySelector?: (item: T) => number): Observable<number>;
+		average(keySelector?: (value: T, index: number, source: Observable<T>) => number, thisArg?: any): Observable<number>;
+
+		sequenceEqual<TOther>(second: Observable<TOther>, comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
+		sequenceEqual(second: Observable<T>): Observable<boolean>;
+		sequenceEqual<TOther>(second: TOther[], comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
+		sequenceEqual(second: T[]): Observable<boolean>;
 
-		sequenceEqual(second: Observable<T>, comparer?: (value1: T, value2: T) => number): Observable<T>;
 		elementAt(index: number): Observable<T>;
-		elementAtOrDefault(index: number, defaultValue: T): Observable<T>;
+		elementAtOrDefault(index: number, defaultValue?: T): Observable<T>;
 
-		single(): Observable<T>;
-		single(predicate: (item: T) => boolean): Observable<T>;
-		singleOrDefault(): Observable<T>;
-		singleOrDefault(predicate: (item: T) => boolean): Observable<T>;
-		singleOrDefault(predicate: (item: T) => boolean, defaultValue: T): Observable<T>;
+		single(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		singleOrDefault(predicate?: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T, thisArg?: any): Observable<T>;
 
-		first(): Observable<T>;
-		first(predicate: (item: T) => boolean): Observable<T>;
-		firstOrDefault(): Observable<T>;
-		firstOrDefault(predicate: (item: T) => boolean): Observable<T>;
-		firstOrDefault(predicate: (item: T) => boolean, defaultValue: T): Observable<T>;
+		first(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		firstOrDefault(predicate?: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T, thisArg?: any): Observable<T>;
 
-		last(): Observable<T>;
-		last(predicate: (item: T) => boolean): Observable<T>;
-		lastOrDefault(): Observable<T>;
-		lastOrDefault(predicate: (item: T) => boolean): Observable<T>;
-		lastOrDefault(predicate: (item: T) => boolean, defaultValue: T): Observable<T>;
+		last(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		lastOrDefault(predicate?: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T, thisArg?: any): Observable<T>;
 	}
 }
\ No newline at end of file