Merge commit '04ac6066b5d719a1d9b179c50ee2719c6b80d8ba'

angularjs/angular.d.ts

@@ -926,7 +926,7 @@ declare module ng {
          *
          * @param reason Constant, message, exception or an object representing the rejection reason.
          */
-        reject(reason?: any): IPromise<void>;
+        reject(reason?: any): IPromise<any>;
         /**
          * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted.
          *

breeze/breeze.d.ts

@@ -654,7 +654,7 @@ declare module breeze {
         getEntityTypes(): IStructuralType[];
         hasMetadataFor(serviceName: string): boolean;
         static importMetadata(exportedString: string): MetadataStore;
-        importMetadata(exportedString: string): MetadataStore;
+        importMetadata(exportedString: string, allowMerge?: boolean): MetadataStore;
         isEmpty(): boolean;
         registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) =>void ): void;
         trackUnmappedType(entityCtor: Function, interceptor?: Function): void;

clone/clone-tests.ts

@@ -6,4 +6,5 @@ var original = {
 
 var copy = clone(original);
 copy = clone(original, false);
-copy = clone(original, true);
+copy = clone(original, true, 1);
+copy = clone.clonePrototype(original);

clone/clone.d.ts

@@ -8,10 +8,18 @@
  */
 declare module "clone" {
     /**
-     * @param parent
-     * @param circular If not given, defaults to true in JS lib.
+     * @param val the value that you want to clone, any type allowed
+     * @param circular Call clone with circular set to false if you are certain that obj contains no circular references. This will give better performance if needed. There is no error if undefined or null is passed as obj.
+     * @param depth to wich the object is to be cloned (optional, defaults to infinity)
      */
-    function clone(parent: Object, circular?: boolean): Object
+    function clone<T>(val: T, circular?: boolean, depth?: number): T;
+
+    module clone {
+        /**
+         * @param obj the object that you want to clone
+         */
+        function clonePrototype<T>(obj: T): T;
+    }
 
     export = clone
 }

each/each-tests.ts

@@ -0,0 +1,41 @@
+/// <reference path="each.d.ts" />
+/// <reference path="../node/node.d.ts" />
+
+function testEach() {
+	var EachStaticClass: EachStatic = function (array: any[]) {
+		return {
+			paused: true,
+			readable: false,
+			started: true,
+			done: true,
+			total: true,
+			on: function (eventName: string, cb: (a: any, b?: () => void) => void) {
+				return EachStaticClass([]);
+			},
+			parallel: function (mode: any) {
+				return EachStaticClass([]);
+			},
+			shift: function (items: any[]) {},
+			write: function (items: any[]) {},
+			unshift: function (items: any[]) {},
+			end: function () {
+				return EachStaticClass([]);
+			},
+			times: function () {
+				return EachStaticClass([]);
+			},
+			repeat: function () {
+				return EachStaticClass([]);
+			},
+			sync: function () {
+				return EachStaticClass([]);
+			},
+			files: function (a: any, glob?: any) {}
+		};
+	};
+
+	var each: Each = EachStaticClass([1, 2, 3]);
+
+	var EachReq: EachStatic = require("each");
+	var each: Each = EachReq([4, 5, 6]);
+}

each/each.d.ts

@@ -0,0 +1,39 @@
+// Type definitions for NodeEach v0.4.9
+// Project: http://www.adaltas.com/projects/node-each/
+// Definitions by: Michael Zabka <https://github.com/misak113/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface Each {
+	paused: boolean;
+	readable: boolean;
+	started: boolean;
+	done: boolean;
+	total: boolean;
+	on(eventName: string, onCallback: Function): Each;
+	on(eventName: "item", onItem: (item: any, next: (error?: Error) => void) => void): Each;
+	on(eventName: "error", onError: (error: Error[]) => void): Each;
+	on(eventName: "error", onError: (error: Error) => void): Each;
+	on(eventName: "both", onBoth: (error?: Error[]) => void): Each;
+	on(eventName: "end", onEnd: () => void): Each;
+	parallel(mode: number): Each;
+	parallel(mode: boolean): Each;
+	shift(items: any[]): void;
+	write(items: any[]): void;
+	unshift(items: any[]): void;
+	end(): Each;
+	times(): Each;
+	repeat(): Each;
+	sync(): Each;
+	files(glob: any): void;
+	files(base: any, glob: any): void;
+}
+
+interface EachStatic {
+	(array: any[]): Each;
+}
+
+declare var each: EachStatic;
+
+declare module "each" {
+	export = each;
+}

jscrollpane/jscrollpane.d.ts

@@ -295,7 +295,7 @@ interface JScrollPaneApi {
 	 * @param animate Should an animation occur. If you don't provide this argument then the animateScroll
 			value from the settings object is used instead.
 	*/
-	scrollToBottom(animate?: boolean);
+	scrollToBottom(animate?: boolean): void;
 	/**
 	 * Hijacks the links on the page which link to content inside the scrollpane. If you have changed the content of
 	 * your page (e.g. via AJAX) and want to make sure any new anchor links to the contents of your scroll pane will
@@ -312,5 +312,5 @@ interface JQuery {
 	/**
 	 * Initialises the jScrollPane on the JQuery object.
 	*/
-	jScrollPane(options?: JScrollPaneSettings);
+	jScrollPane(options?: JScrollPaneSettings): JQuery;
 }

lazy.js/lazy.js-tests.ts

@@ -3,10 +3,10 @@
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 interface Foo {
-	foo(): string;
+    foo(): string;
 }
 interface Bar {
-	bar(): string;
+    bar(): string;
 }
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -51,38 +51,38 @@ function fnValueCallback(value: Foo): void {
 }
 
 function fnGetKeyCallback(value: Foo): string {
-	return str;
+    return str;
 }
 
 function fnTestCallback(value: Foo): boolean {
-	return bool;
+    return bool;
 }
 
 function fnMapCallback(value: Foo): Bar {
-	return bar;
+    return bar;
 }
 
 function fnMapStringCallback(value: string): string {
-	return str;
+    return str;
 }
 
 function fnNumberCallback(value: Foo): number {
-	return num;
+    return num;
 }
 
 function fnMemoCallback(memo: Bar, value: Foo): Bar {
-	return bar;
+    return bar;
 }
 
 function fnGeneratorCallback(index: number): Foo {
-	return foo;
+    return foo;
 }
 
 // Lazy
 
 fooArraySeq = Lazy(fooArr);
-fooObjectSeq = Lazy<Foo>({a:foo, b:foo});
-anyObjectSeq = Lazy<any>({a:num, b:str});
+fooObjectSeq = Lazy<Foo>({a: foo, b: foo});
+anyObjectSeq = Lazy<any>({a: num, b: str});
 stringSeq = Lazy(str);
 
 // Strict

lazy.js/lazy.js.d.ts

@@ -5,243 +5,244 @@
 
 declare module LazyJS {
 
-	interface LazyStatic {
+    interface LazyStatic {
 
-		(value: string):StringLikeSequence;
-		<T>(value: T[]):ArrayLikeSequence<T>;
-		(value: any[]):ArrayLikeSequence<any>;
-		<T>(value: Object):ObjectLikeSequence<T>;
-		(value: Object):ObjectLikeSequence<any>;
+        (value: string): StringLikeSequence;
+        <T>(value: T[]): ArrayLikeSequence<T>;
+        (value: any[]): ArrayLikeSequence<any>;
+        <T>(value: Object): ObjectLikeSequence<T>;
+        (value: Object): ObjectLikeSequence<any>;
 
-		strict():LazyStatic;
+        strict(): LazyStatic;
 
-		generate<T>(generatorFn: GeneratorCallback<T>, length?: number):GeneratedSequence<T>;
+        generate<T>(generatorFn: GeneratorCallback<T>, length?: number): GeneratedSequence<T>;
 
-		range(to: number):GeneratedSequence<number>;
-		range(from: number, to: number, step?: number):GeneratedSequence<number>;
+        range(to: number): GeneratedSequence<number>;
+        range(from: number, to: number, step?: number): GeneratedSequence<number>;
 
-		repeat<T>(value: T, count?: number):GeneratedSequence<T>;
+        repeat<T>(value: T, count?: number): GeneratedSequence<T>;
 
-		on<T>(eventType: string):Sequence<T>;
+        on<T>(eventType: string): Sequence<T>;
 
-		readFile(path: string):StringLikeSequence;
-		makeHttpRequest(path: string):StringLikeSequence;
-	}
+        readFile(path: string): StringLikeSequence;
+        makeHttpRequest(path: string): StringLikeSequence;
+    }
 
-	interface ArrayLike<T> {
-		length:number;
-		[index:number]:T;
-	}
+    interface ArrayLike<T> {
+        length: number;
+        [index: number]: T;
+    }
 
-	interface Callback {
-		():void;
-	}
+    interface Callback {
+        (): void;
+    }
 
-	interface ErrorCallback {
-		(error: any):void;
-	}
+    interface ErrorCallback {
+        (error: any): void;
+    }
 
-	interface ValueCallback<T> {
-		(value: T):void;
-	}
+    interface ValueCallback<T> {
+        (value: T): void;
+    }
 
-	interface GetKeyCallback<T> {
-		(value: T):string;
-	}
+    interface GetKeyCallback<T> {
+        (value: T): string;
+    }
 
-	interface TestCallback<T> {
-		(value: T):boolean;
-	}
+    interface TestCallback<T> {
+        (value: T): boolean;
+    }
 
-	interface MapCallback<T, U> {
-		(value: T):U;
-	}
+    interface MapCallback<T, U> {
+        (value: T): U;
+    }
 
-	interface MapStringCallback {
-		(value: string):string;
-	}
+    interface MapStringCallback {
+        (value: string): string;
+    }
 
-	interface NumberCallback<T> {
-		(value: T):number;
-	}
+    interface NumberCallback<T> {
+        (value: T): number;
+    }
 
-	interface MemoCallback<T, U> {
-		(memo: U, value: T):U;
-	}
+    interface MemoCallback<T, U> {
+        (memo: U, value: T): U;
+    }
 
-	interface GeneratorCallback<T> {
-		(index: number):T;
-	}
+    interface GeneratorCallback<T> {
+        (index: number): T;
+    }
 
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-	interface Iterator<T> {
-		new (sequence: Sequence<T>):Iterator<T>;
-		current():T;
-		moveNext():boolean;
-	}
+    interface Iterator<T> {
+        new (sequence: Sequence<T>): Iterator<T>;
+        current(): T;
+        moveNext(): boolean;
+    }
 
-	interface GeneratedSequence<T> extends Sequence<T> {
-		new(generatorFn: GeneratorCallback<T>, length: number):GeneratedSequence<T>;
-		length():number;
-	}
+    interface GeneratedSequence<T> extends Sequence<T> {
+        new(generatorFn: GeneratorCallback<T>, length: number): GeneratedSequence<T>;
+        length(): number;
+    }
 
-	interface AsyncSequence<T> extends SequenceBase<T> {
-		each(callback: ValueCallback<T>):AsyncHandle<T>;
-	}
+    interface AsyncSequence<T> extends SequenceBase<T> {
+        each(callback: ValueCallback<T>): AsyncHandle<T>;
+    }
 
-	interface AsyncHandle<T> {
-		cancel():void;
-		onComplete(callback: Callback):void;
-		onError(callback: ErrorCallback):void;
-	}
+    interface AsyncHandle<T> {
+        cancel(): void;
+        onComplete(callback: Callback): void;
+        onError(callback: ErrorCallback): void;
+    }
 
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-	module Sequence {
-		function define(methodName: string[], overrides: Object): Function;
-	}
+    module Sequence {
+        function define(methodName: string[], overrides: Object): Function;
+    }
 
-	interface Sequence<T> extends SequenceBase<T> {
-		each(eachFn: ValueCallback<T>):Sequence<T>;
-	}
+    interface Sequence<T> extends SequenceBase<T> {
+        each(eachFn: ValueCallback<T>): Sequence<T>;
+    }
 
-	interface SequenceBase<T> extends SequenceBaser<T> {
-		first():any;
-		first(count: number):Sequence<T>;
-		indexOf(value: any, startIndex?: number):Sequence<T>;
+    interface SequenceBase<T> extends SequenceBaser<T> {
+        first(): any;
+        first(count: number): Sequence<T>;
+        indexOf(value: any, startIndex?: number): Sequence<T>;
 
-		last():any;
-		last(count: number):Sequence<T>;
-		lastIndexOf(value: any):Sequence<T>;
+        last(): any;
+        last(count: number): Sequence<T>;
+        lastIndexOf(value: any): Sequence<T>;
 
-		reverse():Sequence<T>;
-	}
+        reverse(): Sequence<T>;
+    }
 
-	interface SequenceBaser<T> {
-		// TODO improve define() (needs ugly overload)
-		async(interval: number):AsyncSequence<T>;
-		chunk(size: number):Sequence<T>;
-		compact():Sequence<T>;
-		concat(var_args: T[]):Sequence<T>;
-		consecutive(length: number):Sequence<T>;
-		contains(value: T):boolean;
-		countBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
-		countBy(propertyName: string): ObjectLikeSequence<T>;
-		dropWhile(predicateFn: TestCallback<T>): Sequence<T>;
-		every(predicateFn: TestCallback<T>): boolean;
-		filter(predicateFn: TestCallback<T>): Sequence<T>;
-		find(predicateFn: TestCallback<T>): Sequence<T>;
-		findWhere(properties: Object): Sequence<T>;
+    interface SequenceBaser<T> {
+        // TODO improve define() (needs ugly overload)
+        async(interval: number): AsyncSequence<T>;
+        chunk(size: number): Sequence<T>;
+        compact(): Sequence<T>;
+        concat(var_args: T[]): Sequence<T>;
+        consecutive(length: number): Sequence<T>;
+        contains(value: T): boolean;
+        countBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
+        countBy(propertyName: string): ObjectLikeSequence<T>;
+        dropWhile(predicateFn: TestCallback<T>): Sequence<T>;
+        every(predicateFn: TestCallback<T>): boolean;
+        filter(predicateFn: TestCallback<T>): Sequence<T>;
+        find(predicateFn: TestCallback<T>): Sequence<T>;
+        findWhere(properties: Object): Sequence<T>;
 
-		flatten(): Sequence<T>;
-		groupBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
-		initial(count?: number): Sequence<T>;
-		intersection(var_args: T[]): Sequence<T>;
-		invoke(methodName: string): Sequence<T>;
-		isEmpty(): boolean;
-		join(delimiter?: string): string;
-		map<U>(mapFn: MapCallback<T, U>): Sequence<U>;
+        flatten(): Sequence<T>;
+        groupBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
+        initial(count?: number): Sequence<T>;
+        intersection(var_args: T[]): Sequence<T>;
+        invoke(methodName: string): Sequence<T>;
+        isEmpty(): boolean;
+        join(delimiter?: string): string;
+        map<U>(mapFn: MapCallback<T, U>): Sequence<U>;
 
-		max(valueFn?: NumberCallback<T>): T;
-		min(valueFn?: NumberCallback<T>): T;
-		pluck(propertyName: string): Sequence<T>;
-		reduce<U>(aggregatorFn: MemoCallback<T, U>, memo?: U): U;
-		reduceRight<U>(aggregatorFn: MemoCallback<T, U>, memo: U): U;
-		reject(predicateFn: TestCallback<T>): Sequence<T>;
-		rest(count?: number): Sequence<T>;
-		shuffle(): Sequence<T>;
-		some(predicateFn?: TestCallback<T>): boolean;
-		sortBy(sortFn: NumberCallback<T>): Sequence<T>;
-		sortedIndex(value: T): Sequence<T>;
-		sum(valueFn?: NumberCallback<T>): Sequence<T>;
-		takeWhile(predicateFn: TestCallback<T>): Sequence<T>;
-		union(var_args: T[]): Sequence<T>;
-		uniq(): Sequence<T>;
-		where(properties: Object): Sequence<T>;
-		without(var_args: T[]): Sequence<T>;
-		zip(var_args: T[]): Sequence<T>;
+        max(valueFn?: NumberCallback<T>): T;
+        min(valueFn?: NumberCallback<T>): T;
+        pluck(propertyName: string): Sequence<T>;
+        reduce<U>(aggregatorFn: MemoCallback<T, U>, memo?: U): U;
+        reduceRight<U>(aggregatorFn: MemoCallback<T, U>, memo: U): U;
+        reject(predicateFn: TestCallback<T>): Sequence<T>;
+        rest(count?: number): Sequence<T>;
+        shuffle(): Sequence<T>;
+        some(predicateFn?: TestCallback<T>): boolean;
+        sortBy(sortFn: NumberCallback<T>): Sequence<T>;
+        sortedIndex(value: T): Sequence<T>;
+        size(): number;
+        sum(valueFn?: NumberCallback<T>): Sequence<T>;
+        takeWhile(predicateFn: TestCallback<T>): Sequence<T>;
+        union(var_args: T[]): Sequence<T>;
+        uniq(): Sequence<T>;
+        where(properties: Object): Sequence<T>;
+        without(var_args: T[]): Sequence<T>;
+        zip(var_args: T[]): Sequence<T>;
 
-		toArray(): T[];
-		toObject(): Object;
-	}
+        toArray(): T[];
+        toObject(): Object;
+    }
 
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-	module ArrayLikeSequence {
-		function define(methodName: string[], overrides: Object): Function;
-	}
+    module ArrayLikeSequence {
+        function define(methodName: string[], overrides: Object): Function;
+    }
 
-	interface ArrayLikeSequence<T> extends Sequence<T> {
-		// define()X;
-		concat(): ArrayLikeSequence<T>;
-		first(count?: number): ArrayLikeSequence<T>;
-		get(index: number): T;
-		length(): number;
-		map<U>(mapFn: MapCallback<T, U>): ArrayLikeSequence<U>;
-		pop(): ArrayLikeSequence<T>;
-		rest(count?: number): ArrayLikeSequence<T>;
-		reverse(): ArrayLikeSequence<T>;
-		shift(): ArrayLikeSequence<T>;
-		slice(begin: number, end?: number): ArrayLikeSequence<T>;
-	}
+    interface ArrayLikeSequence<T> extends Sequence<T> {
+        // define()X;
+        concat(): ArrayLikeSequence<T>;
+        first(count?: number): ArrayLikeSequence<T>;
+        get(index: number): T;
+        length(): number;
+        map<U>(mapFn: MapCallback<T, U>): ArrayLikeSequence<U>;
+        pop(): ArrayLikeSequence<T>;
+        rest(count?: number): ArrayLikeSequence<T>;
+        reverse(): ArrayLikeSequence<T>;
+        shift(): ArrayLikeSequence<T>;
+        slice(begin: number, end?: number): ArrayLikeSequence<T>;
+    }
 
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-	module ObjectLikeSequence {
-		function define(methodName: string[], overrides: Object): Function;
-	}
+    module ObjectLikeSequence {
+        function define(methodName: string[], overrides: Object): Function;
+    }
 
-	interface ObjectLikeSequence<T> extends Sequence<T> {
-		assign(other: Object): ObjectLikeSequence<T>;
-		// throws error
-		//async(): X;
-		defaults(defaults: Object): ObjectLikeSequence<T>;
-		functions(): Sequence<T>;
-		get(property: string): ObjectLikeSequence<T>;
-		invert(): ObjectLikeSequence<T>;
-		keys(): Sequence<string>;
-		omit(properties: string[]): ObjectLikeSequence<T>;
-		pairs(): Sequence<T>;
-		pick(properties: string[]): ObjectLikeSequence<T>;
-		toArray(): T[];
-		toObject(): Object;
-		values(): Sequence<T>;
-	}
+    interface ObjectLikeSequence<T> extends Sequence<T> {
+        assign(other: Object): ObjectLikeSequence<T>;
+        // throws error
+        //async(): X;
+        defaults(defaults: Object): ObjectLikeSequence<T>;
+        functions(): Sequence<T>;
+        get(property: string): ObjectLikeSequence<T>;
+        invert(): ObjectLikeSequence<T>;
+        keys(): Sequence<string>;
+        omit(properties: string[]): ObjectLikeSequence<T>;
+        pairs(): Sequence<T>;
+        pick(properties: string[]): ObjectLikeSequence<T>;
+        toArray(): T[];
+        toObject(): Object;
+        values(): Sequence<T>;
+    }
 
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-	module StringLikeSequence {
-		function define(methodName: string[], overrides: Object): Function;
-	}
+    module StringLikeSequence {
+        function define(methodName: string[], overrides: Object): Function;
+    }
 
-	interface StringLikeSequence extends SequenceBaser<string> {
-		charAt(index: number): string;
-		charCodeAt(index: number): number;
-		contains(value: string): boolean;
-		endsWith(suffix: string): boolean;
+    interface StringLikeSequence extends SequenceBaser<string> {
+        charAt(index: number): string;
+        charCodeAt(index: number): number;
+        contains(value: string): boolean;
+        endsWith(suffix: string): boolean;
 
-		first(): string;
-		first(count: number): StringLikeSequence;
+        first(): string;
+        first(count: number): StringLikeSequence;
 
-		indexOf(substring: string, startIndex?: number): number;
+        indexOf(substring: string, startIndex?: number): number;
 
-		last(): string;
-		last(count: number): StringLikeSequence;
+        last(): string;
+        last(count: number): StringLikeSequence;
 
-		lastIndexOf(substring: string, startIndex?: number): number;
-		mapString(mapFn: MapStringCallback): StringLikeSequence;
-		match(pattern: RegExp): StringLikeSequence;
-		reverse(): StringLikeSequence;
+        lastIndexOf(substring: string, startIndex?: number): number;
+        mapString(mapFn: MapStringCallback): StringLikeSequence;
+        match(pattern: RegExp): StringLikeSequence;
+        reverse(): StringLikeSequence;
 
-		split(delimiter: string): StringLikeSequence;
-		split(delimiter: RegExp): StringLikeSequence;
+        split(delimiter: string): StringLikeSequence;
+        split(delimiter: RegExp): StringLikeSequence;
 
-		startsWith(prefix: string): boolean;
-		substring(start: number, stop?: number): StringLikeSequence;
-		toLowerCase(): StringLikeSequence;
-		toUpperCase(): StringLikeSequence;
-	}
+        startsWith(prefix: string): boolean;
+        substring(start: number, stop?: number): StringLikeSequence;
+        toLowerCase(): StringLikeSequence;
+        toUpperCase(): StringLikeSequence;
+    }
 }
 
 declare var Lazy: LazyJS.LazyStatic;

lodash/lodash.d.ts

@@ -6179,6 +6179,18 @@ declare module _ {
         **/
         parseInt(value: string): number;
     }
+    
+    
+    //_.property
+    interface LoDashStatic {
+        /**
+         * # Ⓢ
+         * Creates a "_.pluck" style function, which returns the key value of a given object.
+         * @param key (string)
+         * @return the value of that key on the object
+         **/
+        property<T,RT>(key: string): (obj: T) => RT;
+    }
 
     //_.random
     interface LoDashStatic {

marionette/marionette.d.ts

@@ -213,7 +213,7 @@ declare module Marionette {
 
         modelEvents: any;
         collectionEvents: any;
-        ui: any;
+        ui(): any;
 
         getTemplate(): any;
         mixinTemplateHelpers(target?: any): any;
@@ -232,7 +232,7 @@ declare module Marionette {
 
         constructor(options?: any);
 
-        ui: any;
+        ui(): any;
 
         serializeData(): any;
         render(): ItemView<TModel>;

node/node.d.ts

@@ -631,7 +631,11 @@ declare module "child_process" {
         killSignal?: string;
     }, callback: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
     export function exec(command: string, callback: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
-    export function execFile(file: string, args: string[], options: {
+    export function execFile(file: string,
+        callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
+    export function execFile(file: string, args?: string[],
+        callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
+    export function execFile(file: string, args?: string[], options?: {
         cwd?: string;
         stdio?: any;
         customFds?: any;
@@ -640,7 +644,7 @@ declare module "child_process" {
         timeout?: number;
         maxBuffer?: string;
         killSignal?: string;
-    }, callback: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
+    }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
     export function fork(modulePath: string, args?: string[], options?: {
         cwd?: string;
         env?: any;

sigmajs/sigmajs-tests.ts

@@ -62,4 +62,11 @@ module SigmaJsTests {
     s.killForceAtlas2();
     s.startForceAtlas2();
     s.stopForceAtlas2();
+
+    s.cameras[0].goTo({
+        angle: 0,
+        x: 100,
+        y: 100,
+        ratio: 1
+    });
 }

sigmajs/sigmajs.d.ts

@@ -5,6 +5,21 @@
 
 /// <reference path="../jquery/jquery.d.ts" />
 declare module SigmaJs{
+    interface Animation {
+        camera(camera: Camera, target: { [index: string]: any }, options: { [index: string]: any }): number;
+    }
+
+    interface Camera {
+        angle: number;
+        cameraPosition(x: number, y:number): {x: number; y: number};
+        goTo(settings: { [index: string]: any }): void;
+        graphPosition(x: number, y:number): {x: number; y: number};
+        ratio: number;
+        readPrefix: string;
+        x: number;
+        y: number;
+    }
+
     interface Classes {
         configurable: Configurable;
         graph: Graph;
@@ -56,6 +71,10 @@ declare module SigmaJs{
         nodes(ids: string[]): Node[];
     }
 
+    interface Miscellaneous {
+        animation: Animation;
+    }
+
     interface Node {
         color?: string;
         id: string;
@@ -75,9 +94,12 @@ declare module SigmaJs{
     }
 
     interface Renderer {
+        container: Element;
         refresh(): Sigma;
         render(): Sigma;
         resize(): Sigma;
+        settings(settings: { [index: string]: any }): void;
+        settings(settings: { [index: string]: any }): void;
     }
 
     interface RendererConfigs{
@@ -90,12 +112,14 @@ declare module SigmaJs{
         addRenderer(): Renderer;
         addRenderer(configs: RendererConfigs): Renderer;
         bind(event: string, callback: (e: any) => void): void;
+        cameras: Camera[];
         graph: Graph;
         killRenderer(renderer: string): Sigma;
         killRenderer(renderer: Renderer): Sigma;
         kill(): void;
         refresh(): void;
         renderers: Renderer[];
+        settings(key: string): any;
 
         // forceAtlas2 layout
         configForceAtlas2(configs: { [key: string]: any }): void;
@@ -121,6 +145,7 @@ declare module SigmaJs{
         new(container: Element): Sigma;
         new(configuration: SigmaConfigs): Sigma;
         classes:Classes;
+        misc: Miscellaneous;
         parsers: Parsers;
         plugins: Plugins;
     }

sipml/sipml.d.ts

@@ -19,7 +19,7 @@ declare module SIPml {
     public removeEventListener(type: any): void;
   }
 
-  class Session {
+  class Session extends EventTarget {
     public accept(configuration?: Session.Configuration): number;
     public getId(): number;
     public getRemoteFriendlyName(): string;
@@ -30,14 +30,14 @@ declare module SIPml {
 
   export module Session {
     interface Configuration {
-      audio_remote?: HTMLAudioElement;
+      audio_remote?: HTMLElement;
       bandwidth?: Object;
       expires?: number;
       from?: string;
       sip_caps?: Object[];
       sip_headers?: Object[];
-      video_local?: HTMLVideoElement;
-      video_remote?: HTMLVideoElement;
+      video_local?: HTMLElement;
+      video_remote?: HTMLElement;
       video_size?: Object;
     }
 
@@ -83,9 +83,9 @@ declare module SIPml {
   class Stack extends EventTarget {
     public constructor(configuration?: Stack.Configuration);
     public setConfiguration(configuration: Stack.Configuration): number;
-    public newSession(type: string, configuration: Stack.Configuration): any;
+    public newSession(type: string, configuration?: Session.Configuration): any;
     public start(): number;
-    public stop(timeout: number): number;
+    public stop(timeout?: number): number;
   }
 
   export module Stack {
@@ -147,3 +147,4 @@ declare module SIPml {
 
   function setWebRtcType(type: string): boolean;
 }
+

svg-pan-zoom/svg-pan-zoom.d.ts

@@ -18,7 +18,7 @@ declare module SvgPanZoom {
         beforeZoom?: (scale:number) => void;
         onZoom?: (scale:number) => void;
         beforePan?: (point:IPoint) => void;
-        onPan?: (point:IPoint) => void;
+        onPan?: (x:number, y:number) => void;
         refreshRate?: any; // in hz
     }
 
@@ -55,7 +55,7 @@ declare module SvgPanZoom {
 
         setBeforePan(fn: (point:IPoint)=> void): void;
 
-        setOnPan(fn: (point:IPoint)=> void): void;
+        setOnPan(fn: (x:number, y:number)=> void): void;
 
         enableZoom(): void;
 

threejs/detector.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Detector.js
+// Type definitions for three.js (Detector.js)
 // Project: https://github.com/mrdoob/three.js/blob/master/examples/js/Detector.js
 // Definitions by: Satoru Kimura <https://github.com/gyohk>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

threejs/three-canvasrenderer.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for CanvasRenderer.js
+// Type definitions for three.js (CanvasRenderer.js)
 // Project: https://github.com/mrdoob/three.js/blob/master/examples/js/renderers/CanvasRenderer.js
 // Definitions by: Satoru Kimura <https://github.com/gyohk>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

threejs/three-copyshader.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for CopyShader.js
+// Type definitions for three.js (CopyShader.js)
 // Project: https://github.com/mrdoob/three.js/blob/r68/examples/js/shaders/CopyShader.js
 // Definitions by: Satoru Kimura <https://github.com/gyohk>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

threejs/three-css3drenderer.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for CSS3DRenderer.js
+// Type definitions for three.js (CSS3DRenderer.js)
 // Project: https://github.com/mrdoob/three.js/blob/master/examples/js/renderers/CSS3DRenderer.js
 // Definitions by: Satoru Kimura <https://github.com/gyohk>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

threejs/three-effectcomposer.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for EffectComposer.js
+// Type definitions for three.js (EffectComposer.js)
 // Project: https://github.com/mrdoob/three.js/blob/r68/examples/js/postprocessing/EffectComposer.js
 // Definitions by: Satoru Kimura <https://github.com/gyohk>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

threejs/three-maskpass.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for MaskPass.js
+// Type definitions for three.js (MaskPass.js)
 // Project: https://github.com/mrdoob/three.js/blob/r68/examples/js/postprocessing/MaskPass.js
 // Definitions by: Satoru Kimura <https://github.com/gyohk>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

threejs/three-orbitcontrols.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for OrbitControls.js
+// Type definitions for three.js (OrbitControls.js)
 // Project: https://github.com/mrdoob/three.js/blob/master/examples/js/controls/OrbitControls.js
 // Definitions by: Satoru Kimura <https://github.com/gyohk>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

threejs/three-projector.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Projector.js
+// Type definitions for three.js (Projector.js)
 // Project: https://github.com/mrdoob/three.js/blob/master/examples/js/renderers/Projector.js
 // Definitions by: Satoru Kimura <https://github.com/gyohk>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

threejs/three-renderpass.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for RenderPass.js
+// Type definitions for three.js (RenderPass.js)
 // Project: https://github.com/mrdoob/three.js/blob/r68/examples/js/postprocessing/RenderPass.js
 // Definitions by: Satoru Kimura <https://github.com/gyohk>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

threejs/three-shaderpass.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for ShaderPass.js
+// Type definitions for three.js (ShaderPass.js)
 // Project: https://github.com/mrdoob/three.js/blob/r68/examples/js/postprocessing/ShaderPass.js
 // Definitions by: Satoru Kimura <https://github.com/gyohk>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

threejs/three-trackballcontrols.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for TrackballControls.js
+// Type definitions for three.js (TrackballControls.js)
 // Project: https://github.com/mrdoob/three.js/blob/master/examples/js/controls/TrackballControls.js
 // Definitions by: Satoru Kimura <https://github.com/gyohk>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

threejs/three.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for three.js r68
+// Type definitions for three.js r69
 // Project: http://mrdoob.github.com/three.js/
 // Definitions by: Kon <http://phyzkit.net/>, Satoru Kimura <https://github.com/gyohk>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped  

traceback/traceback-tests.ts

@@ -0,0 +1,29 @@
+/// <reference path="traceback.d.ts" />
+/// <reference path="../node/node.d.ts" />
+
+function testTraceback() {
+	var TracebackStaticClass: TracebackStatic = function () {
+		return [{
+			name: 'some',
+			path: 'nice',
+			file: 'good',
+			line: 113,
+			col: 32,
+			pos: 43,
+			fun: {'x-x': 'any'},
+			method: 'like',
+			this: { no: "thing"},
+			type: 'goal',
+			origin: ['bad'],
+			is_top: true,
+			is_eval: false,
+			is_native: true,
+			is_ctor: true
+		}];
+	};
+
+	var traceback: Traceback[] = TracebackStaticClass();
+
+	var TBReq: TracebackStatic = require('traceback');
+	var traceback: Traceback[] = TBReq();
+}

traceback/traceback.d.ts

@@ -0,0 +1,32 @@
+// Type definitions for Traceback v0.3.1
+// Project: http://github.com/iriscouch/traceback
+// Definitions by: Michael Zabka <https://github.com/misak113/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface Traceback {
+	name: string; // | The function name
+	path: string; // | The absolute path of the file defining the function
+	file: string; // | The basename of the path file ("example.js")
+	line: number; // | The line number in the file
+	col: number; // | The column number in the file
+	pos: number; // | The byte position in the file
+	fun: any; // | The function itself
+	method: string; // | If this function was called as a method, the name it is stored as
+	this: any; // | The object bound to the label this in the function
+	type: string; // | The type of this; the name of the constructor function (Object, ReadStream, etc.)
+	origin: any; // | The CallSite that ran eval(), if this frame is an eval
+	is_top: boolean; // | Boolean indicating whether the function was called with a global this
+	is_eval: boolean; // | Boolean indicating whether the function comes from an eval() call
+	is_native: boolean; // | Boolean indicating whether the function is native
+	is_ctor: boolean; // | Boolean indicating whether this is a constructor (new) call
+}
+
+interface TracebackStatic {
+	(): Traceback[];
+}
+
+declare var traceback: TracebackStatic;
+
+declare module "traceback" {
+	export = traceback;
+}