Merge pull request #693 from nestalk/fixes

Fixes several definitions for TS 0.9

angularjs/angular-cookies.d.ts

@@ -9,7 +9,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 // ngCookies module (angular-cookies.js)
 ///////////////////////////////////////////////////////////////////////////////
-module ng.cookies {
+declare module ng.cookies {
 
     ///////////////////////////////////////////////////////////////////////////
     // CookieService

angularjs/angular-sanitize.d.ts

@@ -9,7 +9,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 // ngSanitize module (angular-sanitize.js)
 ///////////////////////////////////////////////////////////////////////////////
-module ng.sanitize {
+declare module ng.sanitize {
 
     ///////////////////////////////////////////////////////////////////////////
     // SanitizeService

icheck/icheck-tests.ts

@@ -0,0 +1,34 @@
+///<reference path="icheck.d.ts" />
+///<reference path="../jquery/jquery.d.ts" />
+
+$('input').iCheck({
+    labelHover: false,
+    cursor: true
+});
+
+// customize all inputs (will search for checkboxes and radio buttons)
+$('input').iCheck();
+
+// handle inputs only inside $('.block')
+$('.block input').iCheck();
+
+// handle only checkboxes inside $('.test')
+$('.test input').iCheck({
+    handle: 'checkbox'
+});
+
+// handle .vote class elements (will search inside the element, if it's not an input)
+$('.vote').iCheck();
+
+// you can also change options after inputs are customized
+$('input.some').iCheck({
+    // different options
+});
+
+$('input').on('ifChecked', function (event) {
+    alert(event.type + ' callback');
+});
+
+$('input').iCheck('check', function () {
+    alert('Well done, Sir');
+});

icheck/icheck.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Dániel Tar https://github.com/qcz
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-declare interface ICheckOptions {
+interface ICheckOptions {
 	/**
 	* 'checkbox' or 'radio' to style only checkboxes or radio buttons, both by default
 	*/
@@ -106,7 +106,7 @@ declare interface ICheckOptions {
 	insert?: string;
 }
 
-declare interface JQuery {
+interface JQuery {
 	iCheck(options?: ICheckOptions): JQuery;
-	iCheck(command: string): void;
+	iCheck(command: string, callback?: () => void): void;
 }

iscroll/iscroll-lite.d.ts

@@ -32,7 +32,7 @@ interface iScrollOptions {
     onDestroy?: iScrollEvent;
 }
 
-class iScroll {
+declare class iScroll {
 
     constructor (element: string);
     constructor (element: string, options: iScrollOptions);

iscroll/iscroll.d.ts

@@ -57,7 +57,7 @@ interface iScrollOptions {
     onZoomEnd?: iScrollEvent;
 }
 
-class iScroll {
+declare class iScroll {
 
     constructor (element: string);
     constructor (element: string, options: iScrollOptions);

noVNC/noVNC.d.ts

@@ -87,7 +87,7 @@ interface NvRFBDefaults {
 	onFBResize?: (rfb: RFB, width: number, height: number) => void;
 }
 
-class RFB {
+declare class RFB {
 	constructor(defaults);
 	set_local_cursor(cursor): void;
 	get_display(): Display;

node_zeromq/zmq-tests.ts

@@ -1,7 +1,6 @@
 /// <reference path='zmq.d.ts' />
 
-import zeromq = module('zmq');
-var zmq: zeromq;
+import zmq = module('zmq');
 
 function test1() {
     var sock = zmq.socket('push');

node_zeromq/zmq.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Dave McKeown <http://github.com/davemckeown>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-declare interface EventEmitter {};
+interface EventEmitter {}
 
 declare module 'zmq' {
 

rx.js/rx.js.d.ts

@@ -50,8 +50,8 @@ declare module Rx {
         contains(item: _IDisposable): bool;
         toArray(): _IDisposable[];
     }
-    export module CompositeDisposable {
-        function new (...disposables: _IDisposable[]): ICompositeDisposable;
+    export interface CompositeDisposable {
+        (...disposables: _IDisposable[]): ICompositeDisposable;
     }
 
     // Main disposable class
@@ -61,11 +61,11 @@ declare module Rx {
 
         dispose(): void;
     }
-    export module Disposable {
-        function new (action: () =>void ): IDisposable;
+    export interface Disposable {
+        (action: () =>void ): IDisposable;
 
-        function create(action: () =>void ): _IDisposable;
-        var empty: _IDisposable;
+        create(action: () =>void ): _IDisposable;
+        empty: _IDisposable;
     }
 
     // Single assignment
@@ -78,8 +78,8 @@ declare module Rx {
         getDisposable(): _IDisposable;
         setDisposable(value: _IDisposable): void;
     }
-    export module SingleAssignmentDisposable {
-        function new (): ISingleAssignmentDisposable;
+    export interface SingleAssignmentDisposable {
+        (): ISingleAssignmentDisposable;
     }
 
     // Multiple assignment disposable
@@ -92,8 +92,8 @@ declare module Rx {
         setDisposable(value: _IDisposable): void;
         disposable(value?: _IDisposable): _IDisposable;
     }
-    export module SerialDisposable {
-        function new (): ISerialDisposable;
+    export interface SerialDisposable {
+        (): ISerialDisposable;
     }
 
     interface IRefCountDisposable {
@@ -105,8 +105,8 @@ declare module Rx {
         dispose(): void;
         getDisposable(): _IDisposable;
     }
-    export module RefCountDisposable {
-        function new (disposable: _IDisposable): IRefCountDisposable;
+    export interface RefCountDisposable {
+        (disposable: _IDisposable): IRefCountDisposable;
     }
 
     interface IScheduledItem {
@@ -146,19 +146,19 @@ declare module Rx {
         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 module Scheduler {
-        function new (now: () =>number,
+    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;
 
-        function now(): number;
-        function normalize(timeSpan: number): number;
+        now(): number;
+        normalize(timeSpan: number): number;
 
-        var immediate: IScheduler;
-        var currentThread: ICurrentScheduler;//IScheduler;
-        var timeout: IScheduler;
+        immediate: IScheduler;
+        currentThread: ICurrentScheduler;//IScheduler;
+        timeout: IScheduler;
     }
 
     // Current Thread IScheduler
@@ -207,13 +207,13 @@ declare module Rx {
         value?: any;
         exception?: any;
     }
-    export module Notification {
+    export interface Notification {
         //abstract
         //function new (): INotification;
 
-        function createOnNext(value: any): INotification;//ON
-        function createOnError(exception): INotification;//OE
-        function createOnCompleted(): INotification;//OC
+        createOnNext(value: any): INotification;//ON
+        createOnError(exception): INotification;//OE
+        createOnCompleted(): INotification;//OC
     }
 
     export module  Internals {
@@ -223,10 +223,10 @@ declare module Rx {
             getCurrent(): any;
             dispose(): void;
         }
-        export module Enumerator {
-            function new (moveNext: () =>bool, getCurrent: () => any, dispose: () =>void ): IEnumerator;
+        export interface Enumerator {
+            (moveNext: () =>bool, getCurrent: () => any, dispose: () =>void ): IEnumerator;
 
-            function create(moveNext: () =>bool, getCurrent: () =>any, dispose?: () =>void ): IEnumerator;
+            create(moveNext: () =>bool, getCurrent: () =>any, dispose?: () =>void ): IEnumerator;
         }
 
         // Enumerable
@@ -236,12 +236,12 @@ declare module Rx {
             concat(): IObservable;
             catchException(): IObservable;
         }
-        export module Enumerable {
-            function new (getEnumerator: () =>IEnumerator): IEnumerable;
+        export interface Enumerable {
+            (getEnumerator: () =>IEnumerator): IEnumerable;
 
-            function repeat(value: any, repeatCount?: number): IEnumerable;
-            function forEach(source: any[], selector?: (element: any, index: number) =>any): IEnumerable;
-            function forEach(source: { length: number;[index: number]: any; }, selector?: (element: any, index: number) =>any): IEnumerable;
+            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;
         }
     }
 
@@ -285,8 +285,8 @@ declare module Rx {
         _onError: (exception: any) =>void;
         _onCompleted: () =>void;
     }
-    export module AnonymousObserver {
-        function new (onNext: (value: any) =>void , onError: (exception: any) =>void , onCompleted: () =>void ): IAnonymousObserver;
+    export interface AnonymousObserver {
+        (onNext: (value: any) =>void , onError: (exception: any) =>void , onCompleted: () =>void ): IAnonymousObserver;
     }
 
     interface ICheckedObserver extends IObserver {
@@ -306,8 +306,8 @@ declare module Rx {
 
             ensureActive(): void;
         }
-        export module ScheduledObserver {
-            function new (scheduler: IScheduler, observer: IObserver): IScheduledObserver;
+        export interface ScheduledObserver {
+            (scheduler: IScheduler, observer: IObserver): IScheduledObserver;
         }
     }
 
@@ -379,7 +379,7 @@ declare module Rx {
         takeWhile(predicate: (value: any, index?: number) =>bool): IObservable;
         where(predicate: (value: any, index?: number) => bool): IObservable;
 
-		// time
+        // time
         delay(dueTime: number, scheduler?: IScheduler): IObservable;
         throttle(dueTime: number, scheduler?: IScheduler): IObservable;
         windowWithTime(dueTime: number, timeShiftOrScheduler?: any, scheduler?: IScheduler): IObservable;
@@ -389,41 +389,41 @@ declare module Rx {
         timeout(dueTime: number, other?: IObservable, scheduler?: IScheduler): IObservable;
         delaySubscription(dueTime: number, scheduler?: IScheduler): IObservable;
     }
-    export module Observable {
-        function new (subscribe: (observer: IObserver) =>_IDisposable): IObservable;
+    export interface Observable {
+        (subscribe: (observer: IObserver) =>_IDisposable): IObservable;
 
-        function start(func: () =>any, scheduler?: IScheduler, context?: any): IObservable;
-        function toAsync(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => IObservable;
-        function create(subscribe: (Observer) =>() =>void ): IObservable;
-        function createWithDisposable(subscribe: (Observer) =>_IDisposable): IObservable;
-        function defer(observableFactory: () =>IObservable): IObservable;
-        function empty(scheduler?: IScheduler): IObservable;
-        function fromArray(array: any[], scheduler?: IScheduler): IObservable;
-        function fromArray(array: { length: number;[index: number]: any; }, scheduler?: IScheduler): IObservable;
-        function generate(initialState: any, condition: (state: any) =>bool, iterate: (state: any) =>any, resultSelector: (state: any) =>any, scheduler?: IScheduler): IObservable;
-        function never(): IObservable;
-        function range(start: number, count: number, scheduler?: IScheduler): IObservable;
-        function repeat(value: any, repeatCount?: number, scheduler?: IScheduler): IObservable;
-        function returnValue(value: any, scheduler?: IScheduler): IObservable;
-        function throwException(exception: any, scheduler?: IScheduler): IObservable;
-        function using(resourceFactory: () =>any, observableFactory: (resource: any) =>IObservable): IObservable;
-        function amb(...sources: IObservable[]): IObservable;
-        function catchException(sources: IObservable[]): IObservable;
-        function catchException(...sources: IObservable[]): IObservable;
-        function concat(...sources: IObservable[]): IObservable;
-        function concat(sources: IObservable[]): IObservable;
-        function merge(...sources: IObservable[]): IObservable;
-        function merge(sources: IObservable[]): IObservable;
-        function merge(scheduler: IScheduler, ...sources: IObservable[]): IObservable;
-        function merge(scheduler: IScheduler, sources: IObservable[]): IObservable;
-        function onErrorResumeNext(...sources: IObservable[]): IObservable;
-        function onErrorResumeNext(sources: IObservable[]): IObservable;
+        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;
     }
 
     export module Internals {
         interface IAnonymousObservable extends IObservable { }
-        export module AnonymousObservable {
-            function new (subscribe: (observer: IObserver) =>_IDisposable): IAnonymousObservable;
+        export interface AnonymousObservable {
+            (subscribe: (observer: IObserver) =>_IDisposable): IAnonymousObservable;
         }
     }
 
@@ -439,10 +439,10 @@ declare module Rx {
 
         dispose(): void;
     }
-    export module Subject {
-        function new (): ISubject;
+    export interface Subject {
+        (): ISubject;
 
-        function create(observer: IObserver, observable: IObservable): ISubject;
+        create(observer: IObserver, observable: IObservable): ISubject;
     }
 
     interface IAsyncSubject extends IObservable, IObserver {
@@ -454,8 +454,8 @@ declare module Rx {
 
         dispose(): void;
     }
-    export module AsyncSubject {
-        function new (): IAsyncSubject;
+    export interface AsyncSubject {
+        (): IAsyncSubject;
     }
 
     interface IAnonymousSubject extends IObservable {

rx.js/rx.js.html.d.ts

@@ -1,3 +1,5 @@
+///<reference path="rx.js.d.ts"/>
+
 declare module Rx {
 	export module Observable {
 		function fromEvent(element: HTMLElement, eventName: string) : IObservable;

unity-webapi/unity-webapi.d.ts

@@ -9,7 +9,7 @@ declare class UnitySettings {
    public onInit:Function;
 }
 
-enum UnityPlaybackState {
+declare enum UnityPlaybackState {
    Playing,
    Paused
 }

webrtc/MediaStream.d.ts

@@ -110,7 +110,7 @@ interface MediaStreamTrack {
 	onunmute: (event: Event) => void;
 	onended: (event: Event) => void;
 }
-var MediaStramTrack: {
+declare var MediaStramTrack: {
 	prototype: MediaStreamTrack;
 	new (): MediaStreamTrack;
 	LIVE: number; // = 0;
@@ -118,19 +118,19 @@ var MediaStramTrack: {
 	ENDED: number; // = 2;
 }
 
-interface URL {
-	createObjectURL(stream: MediaStream): string;
-}
-var URL: {
-	prototype: MediaStreamTrack;
-	new (): URL;
+interface streamURL extends URL {
 	createObjectURL(stream: MediaStream): string;
 }
+//declare var URL: {
+//	prototype: MediaStreamTrack;
+//	new (): URL;
+//	createObjectURL(stream: MediaStream): string;
+//}
 
-interface WebkitURL extends URL {
+interface WebkitURL extends streamURL {
 }
-var webkitURL: {
+declare var webkitURL: {
 	prototype: WebkitURL;
-	new (): URL;
+    new (): streamURL;
 	createObjectURL(stream: MediaStream): string;
 }

webrtc/RTCPeerConnection.d.ts

@@ -9,7 +9,7 @@
 interface RTCConfiguration {
 	iceServers: RTCIceServer[];
 }
-var RTCConfiguration: {
+declare var RTCConfiguration: {
 	prototype: RTCConfiguration;
 	new (): RTCConfiguration;
 }
@@ -18,21 +18,21 @@ interface RTCIceServer {
 	url: string;
 	credential?: string;
 }
-var RTCIceServer: {
+declare var RTCIceServer: {
 	prototype: RTCIceServer;
 	new (): RTCIceServer;
 }
 
 interface webkitRTCPeerConnection extends RTCPeerConnection {
 }
-var webkitRTCPeerConnection: {
+declare var webkitRTCPeerConnection: {
 	prototype: webkitRTCPeerConnection;
 	new (settings: RTCPeerConnectionConfig, constraints?:MediaConstraints): webkitRTCPeerConnection;
 }
 
 interface IceState {
 }
-var IceState: {
+declare var IceState: {
 	prototype: IceState;
 	new (): IceState;
 }
@@ -51,7 +51,7 @@ interface RTCSessionDescription {
 	type?: RTCSdpType;
 	sdp?: string;
 }
-var RTCSessionDescription: {
+declare var RTCSessionDescription: {
 	prototype: RTCSessionDescription;
 	new (descriptionInitDict?: RTCSessionDescriptionInit): RTCSessionDescription;
 }
@@ -60,7 +60,7 @@ interface RTCSessionDescriptionInit {
 	type: RTCSdpType;
 	sdp: string;
 }
-var RTCSessionDescriptionInit: {
+declare var RTCSessionDescriptionInit: {
 	prototype: RTCSessionDescriptionInit;
 	new (): RTCSessionDescriptionInit;
 }
@@ -75,13 +75,13 @@ interface RTCDataChannelInit {
 	reliable: bool;
 }
 
-enum RTCSdpType {
+declare enum RTCSdpType {
 	offer,
 	pranswer,
 	answer
 }
 
-enum RTCDataChannelState {
+declare enum RTCDataChannelState {
 	connecting,
 	open,
 	closing,
@@ -112,7 +112,7 @@ interface RTCDataChannelEvent extends Event {
 	constructor (eventInitDict: RTCDataChannelEventInit);
 	channel: RTCDataChannel;
 }
-var RTCDataChannelEvent: {
+declare var RTCDataChannelEvent: {
 	prototype: RTCDataChannelEvent;
 	new (eventInitDict: RTCDataChannelEventInit);
 }
@@ -186,7 +186,7 @@ interface RTCPeerConnection {
 	onicecandidate: (event: RTCIceCandidateEvent)=> void;
 	onidentityresult: (event: Event)=> void;
 }
-var RTCPeerConnection: {
+declare var RTCPeerConnection: {
 	prototype: RTCPeerConnection;
 	new (configuration: RTCConfiguration, constraints?: MediaConstraints): RTCPeerConnection;
 }
@@ -196,7 +196,7 @@ interface RTCIceCandidate {
 	sdpMid?: string;
 	sdpMLineIndex?: number;
 }
-var RTCIceCandidate: {
+declare var RTCIceCandidate: {
 	prototype: RTCIceCandidate;
 	new (candidateInitDict?: RTCIceCandidate);
 }
@@ -206,7 +206,7 @@ interface RTCIceCandidateInit {
 	sdpMid: string;
 	sdpMLineIndex: number;
 }
-var RTCIceCandidateInit:{
+declare var RTCIceCandidateInit:{
 	prototype: RTCIceCandidateInit;
 	new (): RTCIceCandidateInit;
 }
@@ -215,7 +215,7 @@ interface PeerConnectionIceEvent {
 	peer: RTCPeerConnection;
 	candidate: RTCIceCandidate;
 }
-var PeerConnectionIceEvent: {
+declare var PeerConnectionIceEvent: {
 	prototype: PeerConnectionIceEvent;
 	new (): PeerConnectionIceEvent;
 }
@@ -223,7 +223,7 @@ var PeerConnectionIceEvent: {
 interface RTCPeerConnectionConfig {
 	iceServers: RTCIceServer[];
 }
-var RTCPeerConnectionConfig: {
+declare var RTCPeerConnectionConfig: {
 	prototype: RTCPeerConnectionConfig;
 	new (): RTCPeerConnectionConfig;
 }