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

README.md

@@ -146,6 +146,7 @@ List of Definitions
 * [require.js](http://requirejs.org/) (by [Josh Baldwin](https://github.com/jbaldwin/))
 * [Sammy.js](http://sammyjs.org/) (by [Boris Yankov](https://github.com/borisyankov))
 * [Select2](http://ivaynberg.github.com/select2/) (by [Boris Yankov](https://github.com/borisyankov))
+* [Sencha Touch](http://www.sencha.com/products/touch/) (by [Brian Kotek](https://github.com/brian428))
 * [SignalR](http://www.asp.net/signalr) (by [Boris Yankov](https://github.com/borisyankov))
 * [Sinon](http://sinonjs.org/) (by [William Sears](https://github.com/mrbigdog2u))
 * [socket.io](http://socket.io) (by [William Orr](https://github.com/worr))

angularjs/angular.d.ts

@@ -646,7 +646,7 @@ declare module ng {
         replace?: bool;
         transclude?: bool;
         restrict?: string;
-        scope?: bool;
+        scope?: any;
         link?: Function;
         compile?: Function;
     }

breeze/breeze.d.ts

@@ -360,6 +360,13 @@ declare module breeze {
         rejectChanges(): Entity[];
         saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Promise;
         setProperties(config: EntityManagerProperties): void;
+
+        helper: {
+            unwrapInstance(structObj: Entity, isOData: bool): any;
+            unwrapOriginalValues(target: Entity, metadataStore: MetadataStore, isOData: bool): any;
+            unwrapChangedValues(target: Entity, metadataStore: MetadataStore, isOData: bool): any;
+            getEntityKeyFromRawEntity(rawEntity: any, entityType: EntityType, isClient: bool): EntityKey;
+        };
     }
 
     interface EntityManagerOptions {
@@ -586,7 +593,8 @@ declare module breeze {
         isEmpty(): bool;
         registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) =>void ): void;
         trackUnmappedType(entityCtor: Function, interceptor?: Function);
-    }
+        setEntityTypeForResourceName(resourceName: string, entityTypeOrName: string): void;
+ }
 
     interface MetadataStoreOptions {
         namingConvention?: NamingConvention;

colors/colors.d.ts

@@ -0,0 +1,22 @@
+// Type definitions for Colors.js 0.6.0-1
+// Project: https://github.com/Marak/colors.js
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare interface String {
+    bold:string;
+    italic:string;
+    underline:string;
+    inverse:string;
+    yellow:string;
+    cyan:string;
+    white:string;
+    magenta:string;
+    green:string;
+    red:string;
+    grey:string;
+    blue:string;
+    rainbow:string;
+    zebra:string;
+    random:string;
+}

colors/colors.test.ts

@@ -0,0 +1,5 @@
+
+///<reference path="colors.d.ts" />
+
+var test:string = 'test';
+var arr:string[] = ['color', 'odd'.italic.zebra, 'radical'.bold.rainbow, test.underline + 'super'.green];

easeljs/easeljs.d.ts

@@ -11,14 +11,14 @@
 */
 
 
-/// <reference path="../tweenjs/tweenjs.d.ts" />
+/// <reference path="tweenjs.d.ts" />
 
 // rename the native MouseEvent, to avoid conflit with createjs's MouseEvent
 interface NativeMouseEvent extends MouseEvent {
 
 }
 
-module createjs {
+declare module createjs {
     // :: base classes :: //
 
     export class DisplayObject {
@@ -155,13 +155,15 @@ module createjs {
         spriteSheet: SpriteSheet;
 
         // methods
-        constructor (spriteSheet: SpriteSheet);
+        constructor(spriteSheet: SpriteSheet);
         advance(): void;
         cache(): void;
         clone(): BitmapAnimation;
         getBounds(): Rectangle;
         gotoAndPlay(frameOrAnimation: string): void;
         gotoAndPlay(frameOrAnimation: number): void;
+        gotoAndStop(frameOrAnimation: string): void;
+        gotoAndStop (frameOrAnimation: number): void;
         play(): void;
         stop(): void;
         updateCache(): void;
@@ -670,6 +672,17 @@ module createjs {
         // events
         tick: (timeElapsed: number) => any;
     }
+    
+     export class TickerEvent {
+
+        // properties
+        target: Object;
+        type: string;
+        paused: bool;
+        delta: number;
+        time: number;
+        runTime : number;
+    }
 
 
     export class Touch {
@@ -684,4 +697,4 @@ module createjs {
         // methods
         static get(): number;
     }
-}
+}

leaflet/leaflet.d.ts

@@ -1932,7 +1932,7 @@ declare module L {
     
     }
 
-    export class DivIcon {
+    export class DivIcon extends Icon{
         /**
           * Creates a div icon instance with the given options.
           */

msnodesql/msnodesql.d.ts

@@ -7,37 +7,52 @@
 ///<reference path='../node/node.d.ts' />
 
 declare module "msnodesql" {
-    export function open(connectionString: string, callback: Function): Connection;
+    export function open(connectionString: string, callback?: OpenCallback): Connection;
 
-    export function query(connectionString: string, query: string): StreamEvents;
-    export function query(connectionString: string, query: string, callback: Callback): StreamEvents;
-    export function query(connectionString: string, query: string, params, callback: Callback): StreamEvents;
+    export function query(connectionString: string, query: string, callback?: QueryCallback): StreamEvents;
+    export function query(connectionString: string, query: string, params: any[], callback?: QueryCallback): StreamEvents;
 
-    export function queryRaw(connectionString: string, query: string): StreamEvents;
-    export function queryRaw(connectionString: string, query: string, callback: Callback): StreamEvents;
-    export function queryRaw(connectionString: string, query: string, params, callback: Callback): StreamEvents;
+    export function queryRaw(connectionString: string, query: string, callback?: QueryRawCallback): StreamEvents;
+    export function queryRaw(connectionString: string, query: string, params: any[], callback?: QueryRawCallback): StreamEvents;
 
-    interface Callback {
-        (err: Error, results: any[]): void;
+    interface OpenCallback {
+        (err?: Error, connection?: Connection): void;
     }
 
-    interface Errback {
+    interface QueryCallback {
+        (err?: Error, results?: any[], more?: bool): void;
+    }
+
+    interface QueryRawCallback {
+        (err?: Error, results?: QueryRawResult, more?: bool): void;
+    }
+
+    interface QueryRawResult {
+        meta: QueryRawColumn[];
+        rows: any[][];
+    }
+
+    interface QueryRawColumn {
+        name?: string;
+    }
+
+    interface ErrorCallback {
         (err: Error): void;
     }
 
     interface Connection {
-        queryRaw(connectionString: string, query: string): StreamEvents;
-        queryRaw(connectionString: string, query: string, callback: Callback): StreamEvents;
-        queryRaw(connectionString: string, query: string, params, callback: Callback): StreamEvents;
+        queryRaw(query: string, callback?: QueryCallback): StreamEvents;
+        queryRaw(query: string, params: any[], callback?: QueryCallback): StreamEvents;
 
-        query(connectionString: string, query: string): StreamEvents;
-        query(connectionString: string, query: string, callback: Callback): StreamEvents;
-        query(connectionString: string, query: string, params, callback: Callback): StreamEvents;
+        query(query: string, callback?: QueryRawCallback): StreamEvents;
+        query(query: string, params: any[], callback?: QueryRawCallback): StreamEvents;
 
-        beginTransaction(callback?: Errback);
-        commit(callback?: Errback);
-        rollback(callback?: Errback);
-        close(callback?: Errback);
+        beginTransaction(callback?: ErrorCallback);
+        commit(callback?: ErrorCallback);
+        rollback(callback?: ErrorCallback);
+
+        close(callback?: ErrorCallback);
+        close(immediately: bool, callback?: ErrorCallback);
     }
 
     interface StreamEvents extends EventEmitter { }

node/node.d.ts

@@ -30,12 +30,15 @@ declare function setTimeout(callback: () => void , ms: number): any;
 declare function clearTimeout(timeoutId: any);
 declare function setInterval(callback: () => void , ms: number): any;
 declare function clearInterval(intervalId: any);
+declare function setImmediate(callback: () => void ): any;
+declare function clearImmediate(immediateId: any);
 
 declare var require: {
     (id: string): any;
     resolve(id:string): string;
     cache: any;
     extensions: any;
+    main: any;
 }
 
 declare var module: {

q/Q.d.ts

@@ -36,13 +36,13 @@ interface Qpromise {
 }
 
 interface QStatic {
-    when(value: any, onFulfilled: Function, onRejected?: Function): Qpromise;
+    when(value: any, onFulfilled?: Function, onRejected?: Function): Qpromise;
     try(method: Function, ...args: any[]): Qpromise;
     fbind(method: Function, ...args: any[]): Qpromise;
     fcall(method: Function, ...args: any[]): Qpromise;
     all(promises: Qpromise[]): Qpromise;
     allResolved(promises: Qpromise[]): Qpromise;
-    resolve(object?:Qpromise);
+    resolve(object:any):Qpromise;
     spread(onFulfilled: Function, onRejected: Function): Qpromise;
     timeout(ms: number): Qpromise;
     delay(ms: number): Qpromise;

restangular/restangular.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Restangular 0.6.9
+// Type definitions for Restangular v0.8.0 - 2013-06-03
 // Project: https://github.com/mgonto/restangular
 // Definitions by: Boris Yankov <https://github.com/borisyankov/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -10,6 +10,7 @@ interface Restangular extends RestangularCustom {
     one(route: string, id?: number): RestangularElement;
     all(route: string): RestangularCollection;
     copy(fromElement: any): RestangularElement;
+    withConfig(configurer: any): RestangularElement;
 }
 
 interface RestangularElement extends Restangular {

sencha_touch/SenchaTouch-Tests.ts

@@ -0,0 +1,125 @@
+/// <reference path="SenchaTouch.d.ts" />
+
+Ext.application({
+    name: 'Sencha',
+
+    launch: function() {
+        
+        Ext.Viewport.add( <Ext.tab.IPanel>{
+            xtype: 'tabpanel',
+            fullscreen: true,
+            tabBarPosition: 'bottom',
+
+            items: [
+            
+                <Ext.IComponent>{
+                    title: 'Home',
+                    iconCls: 'home',
+                    cls: 'home',
+                    html: [
+                        '<img height=260 src="http://staging.sencha.com/img/sencha.png" />',
+                        '<h1>Welcome to Sencha Touch</h1>',
+                        "<p>Building the Getting Started app.</p>",
+                        '<h2>Sencha Touch</h2>'
+                    ].join("")
+                },
+
+                <Ext.IComponent>{
+                    xtype: 'nestedlist',
+                    title: 'Blog',
+                    iconCls: 'star',
+                    cls: 'blog',
+                    displayField: 'title',
+
+                    store: <Ext.data.ITreeStore>{
+                        type: 'tree',
+
+                        fields: ['title', 'link', 'author', 'contentSnippet', 'content', {
+                            name: 'leaf',
+                            defaultValue: true
+                        }],
+
+                        root: {
+                            leaf: false
+                        },
+
+                        proxy: <Ext.data.proxy.IJsonP>{
+                            type: 'jsonp',
+                            url: 'https://ajax.googleapis.com/ajax/services/feed/load?v=1.0&q=http://feeds.feedburner.com/SenchaBlog',
+                            reader: <Ext.data.reader.IJson>{
+                                type: 'json',
+                                rootProperty: 'responseData.feed.entries'
+                            }
+                        }
+                    },
+
+                    detailCard: <Ext.IPanel>{
+                        xtype: 'panel',
+                        scrollable: true,
+                        styleHtmlContent: true
+                    },
+
+                    listeners: {
+                        itemtap: function(nestedList, list, index, element, post) {
+                            this.getDetailCard().setHtml(post.get('content'));
+                        }
+                    }
+                },
+
+                <Ext.form.IPanel>{
+                    xtype: 'formpanel',
+                    title: 'Contact Us',
+                    iconCls: 'user',
+                    url: 'contact.php',
+                    layout: 'vbox',
+
+                    items: [
+                        <Ext.form.IFieldSet>{
+                            xtype: 'fieldset',
+                            title: 'Contact Us',
+                            instructions: 'Email address is optional',
+
+                            items: [
+                                <Ext.field.IText>{
+                                    xtype: 'textfield',
+                                    label: 'Name',
+                                    name: 'name'
+                                },
+                                <Ext.field.IEmail>{
+                                    xtype: 'emailfield',
+                                    label: 'Email',
+                                    name: 'email'
+                                },
+                                <Ext.field.ITextArea>{
+                                    xtype: 'textareafield',
+                                    label: 'Message',
+                                    name: 'message',
+                                    height: 90
+                                }
+                            ]
+                        },
+                        
+                        <Ext.IButton>{
+                            xtype: 'button',
+                            text: 'Send',
+                            ui: 'confirm',
+
+                            handler: function() {
+
+                                var form = this.up('formpanel');
+
+                                form.submit({
+                                    success: function() {
+                                        Ext.Msg.alert('Thank You', 'Your message has been received', function() {
+                                            form.reset();
+                                        });
+                                    }
+                                });
+                            }
+                        }
+                    ]
+                }
+            ]
+        });
+    }
+});