diff --git a/tabris/README.md b/tabris/README.md
new file mode 100644
index 0000000000..23d3d1a496
--- /dev/null
+++ b/tabris/README.md
@@ -0,0 +1,8 @@
+# TypeScript definitions for Tabris.js
+
+[Tabris.js](http://tabrisjs.com) is a framework for developing mobile apps with native UIs in JavaScript.
+The JavaScript library is available on [npm](https://www.npmjs.com/package/tabris).
+
+Current supported version is 1.2.
+
+See http://definitelytyped.org/guides/contributing.html
diff --git a/tabris/tabris-tests.ts b/tabris/tabris-tests.ts
new file mode 100644
index 0000000000..28ab53cecd
--- /dev/null
+++ b/tabris/tabris-tests.ts
@@ -0,0 +1,302 @@
+/// <reference path="./tabris.d.ts" />
+
+var page = tabris.create("Page", {});
+
+function test_events() {
+  var listener = () => console.log("triggered");
+  var widget = tabris.create("Composite", {});
+  widget.on("foo", listener);
+  widget.trigger("foo", "details");
+  widget.off("foo", listener);
+  widget.off("foo");
+  widget.off(null, listener);
+  widget.off();
+}
+
+function test_Action() {
+  var widget: tabris.Action = tabris.create("Action", {});
+  widget.set("foo", 23);
+  widget.set({
+    image: {src: "http://example.org"},
+    title: "foo",
+    placementPriority: "high"
+  });
+  var self: tabris.Action = widget.on("event", function(widget: tabris.Action) {});
+}
+
+function test_Button() {
+  var widget: tabris.Button = tabris.create("Button", {});
+  widget.set("foo", 23);
+  widget.set({
+    width: 200,
+    height: 400,
+    alignment: "center",
+    image: {src: "http://example.org"},
+    text: "foo"
+  });
+}
+
+function test_CheckBox() {
+  var widget: tabris.CheckBox = tabris.create("CheckBox", {});
+  widget.set("foo", 23);
+  widget.set({
+    selection: true,
+    text: "foo"
+  });
+}
+
+function test_Canvas() {
+  var widget: tabris.Canvas = tabris.create("Canvas", {});
+  widget.set("foo", 23);
+  widget.set({
+  });
+  var ctx: tabris.CanvasContext = widget.getContext("2d", 200, 300);
+}
+
+function test_Cell() {
+  var widget: tabris.Cell = tabris.create("Cell", {});
+  widget.set("foo", 23);
+  widget.set({
+  });
+}
+
+function test_CollectionView() {
+  var widget: tabris.CollectionView = tabris.create("CollectionView", {});
+  widget.set("foo", 23);
+  widget.set({
+    cellType: (item: any) => "foo",
+    initializeCell: (cell: tabris.Cell, type: string) => {},
+    itemHeight: (item: any, type: string) => 23,
+    items: ["foo", "bar", "baz"],
+    refreshEnabled: true,
+    refreshIndicator: true,
+    refreshMessage: "foo"
+  });
+  widget.insert(["item1", "item2"]);
+  widget.insert(["item1", "item2"], 3);
+  widget.refresh();
+  widget.refresh(3);
+  widget.remove(3);
+  widget.remove(3, 2);
+  widget.reveal(23);
+}
+
+function test_Composite() {
+  var widget: tabris.Composite = tabris.create("Composite", {});
+  widget.set("foo", 23);
+  widget.set({
+  });
+}
+
+function test_Drawer() {
+  var widget: tabris.Drawer = tabris.create("Drawer", {});
+  widget.set("foo", 23);
+  widget.set({
+  });
+  var same: tabris.Drawer = widget.open();
+  var same: tabris.Drawer = widget.close();
+}
+
+function test_ImageView() {
+  var widget: tabris.ImageView = tabris.create("ImageView", {});
+  widget.set("foo", 23);
+  widget.set({
+    image: {src: "http://example.com"},
+    scaleMode: "auto"
+  });
+}
+
+function test_Page() {
+  var page: tabris.Page = tabris.create("Page", {});
+  page.set("foo", 23);
+  page.set({
+    image: {src: "http://example.com"},
+    title: "foo",
+    topLevel: true
+  });
+  page.open().close();
+}
+
+function test_PageSelector() {
+  var widget: tabris.PageSelector = tabris.create("PageSelector", {});
+  widget.set("foo", 23);
+  widget.set({
+  });
+}
+
+function test_Picker() {
+  var widget: tabris.Picker = tabris.create("Picker", {});
+  widget.set("foo", 23);
+  widget.set({
+    selection: "foo",
+    selectionIndex: 23,
+    items: ["foo", "bar", "baz"]
+  });
+}
+
+function test_ProgressBar() {
+  var widget: tabris.ProgressBar = tabris.create("ProgressBar", {});
+  widget.set("foo", 23);
+  widget.set({
+    minimum: 0,
+    maximum: 100,
+    selection: 23,
+    state: "normal"
+  });
+}
+
+function test_RadioButton() {
+  var widget: tabris.RadioButton = tabris.create("RadioButton", {});
+  widget.set("foo", 23);
+  widget.set({
+    selection: true,
+    text: "foo"
+  });
+}
+
+function test_ScrollView() {
+  var widget: tabris.ScrollView = tabris.create("ScrollView", {});
+  widget.set("foo", 23);
+  widget.set({
+    direction: "horizontal"
+  });
+}
+
+function test_SearchAction() {
+  var widget: tabris.SearchAction = tabris.create("SearchAction", {});
+  widget.set("foo", 23);
+  widget.set({
+    message: "foo",
+    proposals: ["foo", "bar", "baz"],
+    text: "foo"
+  });
+}
+
+function test_Slider() {
+  var widget: tabris.Slider = tabris.create("Slider", {});
+  widget.set("foo", 23);
+  widget.set({
+    minimum: 0,
+    maximum: 100,
+    selection: 23
+  });
+}
+
+function test_Switch() {
+  var widget: tabris.Switch = tabris.create("Switch", {});
+  widget.set("foo", 23);
+  widget.set({
+    selection: true
+  });
+}
+
+function test_TextInput() {
+  var widget: tabris.TextInput = tabris.create("TextInput", {});
+  widget.set("foo", 23);
+  widget.set({
+    alignment: "center",
+    autoCapitalize: true,
+    autoCorrect: false,
+    editable: true,
+    text: "foo",
+    message: "bar",
+    type: "search",
+    keyboard: "ascii"
+  });
+}
+
+function test_Tab() {
+  var widget: tabris.Tab = tabris.create("Tab", {});
+  widget.set("foo", 23);
+  widget.set({
+    badge: "foo",
+    title: "bar",
+    image: {src: "http://example.org"}
+  });
+}
+
+function test_TabFolder() {
+  var widget: tabris.TabFolder = tabris.create("TabFolder", {});
+  widget.set("foo", 23);
+  widget.set({
+    paging: true,
+    tabBarLocation: "auto",
+    selection: tab1
+  });
+  var tab1: tabris.Tab, tab2: tabris.Tab;
+  var same: tabris.TabFolder = widget.append(tab1, tab2);
+}
+
+function test_TextView() {
+  var widget: tabris.TextView = tabris.create("TextView", {});
+  widget.set("foo", 23);
+  widget.set({
+    alignment: "center",
+    markupEnabled: true,
+    maxLines: 23,
+    text: "foo"
+  });
+}
+
+function test_ToggleButton() {
+  var widget: tabris.ToggleButton = tabris.create("ToggleButton", {});
+  widget.set("foo", 23);
+  widget.set({
+    alignment: "center",
+    image: {src: "http://example.org/"},
+    selection: true,
+    text: "foo"
+  });
+}
+
+function test_Video() {
+  var widget: tabris.Video = tabris.create("Video", {});
+  widget.set("foo", 23);
+  widget.set({
+    url: "http://example.org"
+  });
+}
+
+function test_WebView() {
+  var widget: tabris.WebView = tabris.create("WebView", {});
+  widget.set("foo", 23);
+  widget.set({
+    html: "<html>",
+    url: "http://example.org"
+  });
+}
+
+function test_WidgetCollection() {
+  var collection: tabris.WidgetCollection = page.find();
+  var length: number = collection.length;
+  var grandParents: tabris.WidgetCollection = collection.parent().parent();
+  var grandChildren: tabris.WidgetCollection = collection.children().children();
+  var found: tabris.WidgetCollection = collection.find().find(".class");
+  collection.appendTo(page);
+  collection.dispose();
+}
+
+function test_tabris_app() {
+  tabris.app.installPatch("url", (error: Error, patch: Object) => {});
+  tabris.app.reload();
+}
+
+function test_tabris_device() {
+  var lang: string = tabris.device.get("language");
+  var model: string = tabris.device.get("model");
+  var orient: string = tabris.device.get("orientation");
+  var platform: string = tabris.device.get("platform");
+  var factor: number = tabris.device.get("scaleFactor");
+  var height: number = tabris.device.get("screenHeight");
+  var width: number = tabris.device.get("screenWidth");
+  var version: string = tabris.device.get("version");
+  var same: tabris.Device = tabris.device.on("change:orientation", () => {}).off("change:orientation");
+}
+
+function test_tabris_ui() {
+  var page: tabris.Page = tabris.ui.get("activePage");
+  var bg: string = tabris.ui.get("background");
+  var tc: string = tabris.ui.get("textColor");
+  var visible: boolean = tabris.ui.get("toolbarVisible");
+  var same: tabris.UI = tabris.ui.on("change:activePage", () => {}).off("change:activePage");
+}
diff --git a/tabris/tabris.d.ts b/tabris/tabris.d.ts
new file mode 100644
index 0000000000..9a0b4defe7
--- /dev/null
+++ b/tabris/tabris.d.ts
@@ -0,0 +1,1446 @@
+// Type definitions for Tabris.js v1.2
+// Project: http://tabrisjs.com
+// Definitions by: Tabris.js team <http://github.com/eclipsesource/tabris>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module tabris {
+
+  // Types
+
+  interface Bounds {
+
+    /**
+     * the horizontal offset from the parent's left edge in dip
+     */
+    left: number;
+
+    /**
+     * the vertical offset from the parent's top edge in dip
+     */
+    top: number;
+
+    /**
+     * the width of the widget in dip
+     */
+    width: number;
+
+    /**
+     * the height of the widget in dip
+     */
+    height: number;
+
+  }
+
+  interface Transformation {
+
+    /**
+     * Clock-wise rotation in radians. Defaults to `0`.
+     */
+     rotation: number;
+
+    /**
+     * Horizontal scale factor. Defaults to `1`.
+     */
+    scaleX: number;
+
+    /*
+     * Vertical scale factor. Defaults to `1`.
+     */
+    scaleY: number;
+
+    /**
+     * Horizontal translation (shift) in dip. Defaults to `0`.
+     */
+    translationX: number;
+
+    /**
+     * Vertical translation (shift) in dip. Defaults to `0`.
+     */
+    translationY: number;
+
+  }
+
+  // TODO A plain string can be used as a shorthand, e.g. `"image.jpg"` equals `{src: "image.jpg"}`.
+  interface Image {
+
+    /**
+     * Image path or URL.
+     */
+    src?: string;
+
+    /**
+     * Image width, extracted from the image file when missing.
+     */
+    width?: number;
+
+    /**
+     * Image height, extracted from the image file when missing.
+     */
+    height?: number;
+
+    /**
+     * Image scale factor - the image will be scaled down by this factor.
+     * Ignored when width or height are set.
+     */
+    scale?: number;
+
+  }
+
+  interface CanvasContext {
+    // TODO
+  }
+
+  // Events
+
+  /**
+   * Event handling API supported by widgets and various other objects.
+   */
+  interface EventSupport <T> {
+
+    /**
+     * Adds the *listener* to the list of functions to be notified when *event* is fired.
+     * In the listener function, `this` will point to the object itself. Supports chaining.
+     *
+     * @param event the name of the event to listen on
+     * @param listener the listener function
+     */
+    on (event: string, listener: (target: T, ...args: any[]) => any): T;
+
+    /**
+     * Same as `on`, but removes the listener after it has been invoked by an event.
+     * Supports chaining.
+     *
+     * @param event the name of the event to listen on
+     * @param listener the listener function
+     */
+    once (event: string, listener: (target: T, ...args: any[]) => any): T;
+
+    /**
+     * Removes all listeners for all events from this widget. Supports chaining.
+     */
+    off (): T;
+
+    /**
+     * Removes all listeners for *event* from this widget. Supports chaining.
+     *
+     * @param event the event name to remove listeners for
+     */
+    off (event: string): T;
+
+    /**
+     * Removes all occurrences of *listener* that are bound to *event* from this widget.
+     * Supports chaining.
+     *
+     * @param event the event to remove the listener from
+     * @param listener the listener function to remove
+     */
+    off (event: string, listener: (target: T, ...args: any[]) => any): T;
+
+    /**
+     * Triggers an event on this object. Supports chaining.
+     *
+     * @param event the name of the event to trigger
+     * @param args the arguments to pass to the listener functions
+     */
+    trigger (event: string, ...args: any[]): T;
+
+  }
+
+  interface AnimationOptions {
+
+    /**
+     * The time until the animation starts in ms, defaults to `0`.
+     */
+    delay?: number;
+
+    /**
+     * The duration in ms.
+     */
+    duration: number;
+
+    /**
+     * One of `linear`, `ease-in`, `ease-out`, `ease-in-out`.
+     */
+    easing: string;
+
+    /**
+     * The number of times to repeat the animation, defaults to `0`.
+     */
+    repeat: number;
+
+    /**
+     * `true` to alternate the direction of the animation on every repeat.
+     */
+    reverse: boolean;
+
+    /**
+     * No effect, but will be given in animation events.
+     */
+    name: string;
+
+  }
+
+  // Widget
+
+  function create (type: string, properties: WidgetProperties): Widget<any>;
+
+  /**
+   * API supported by all widgets.
+   */
+  interface Widget <T> extends EventSupport <T> {
+
+    // Property Support
+
+    /**
+     * Gets the current value of the given *property*.
+     *
+     * @param property
+     */
+    get (property: string): any;
+
+    /**
+     * Sets the given property. Supports chaining.
+     *
+     * @param property the name of the property to set
+     * @param value the value to set the property to
+     * @param options passed to the change event resulting from this method call
+     */
+    set (property: string, value: any, options?: Object): T;
+
+    /**
+     * Sets all key-value pairs in the properties object as widget properties. Supports chaining.
+     *
+     * @param properties the properties to set
+     * @param options passed to the change event resulting from this method call
+     */
+    set (properties: WidgetProperties, options?: Object): T;
+
+    /**
+     * Starts an animation that transforms the given properties from their current values to the given ones.
+     * Supported properties are *transform* and *opacity*.
+     *
+     * @param properties The properties and target values to animate.
+     * @param options Configures the animation itself.
+     */
+    animate (properties: WidgetProperties, options: AnimationOptions): void;
+
+    /**
+     * Appends this widget to the given parent.
+     * The parent widget must support children (extending *Composite*).
+     *
+     * @param parent the parent widget to append this one to
+     */
+    appendTo (parent: Composite): T;
+
+    /**
+     * Applies the given properties to all descendants that match the associated selector(s).
+     *
+     * @param properties an object in the format
+     *   `{selector: {property: value, property: value, ... }, selector: ...}`
+     */
+    apply (properties: Object): T;
+
+    /**
+     * Returns a (possibly empty) collection of all children of this widget.
+     */
+    children (): WidgetCollection;
+
+    /**
+     * Returns a (possibly empty) collection of all children of this widget that match the selector.
+     *
+     * @param selector a selector string to filter children
+     */
+    children (selector: string): WidgetCollection;
+
+    /**
+     * Removes this widget from its parent and destroys it. Also disposes of all its children.
+     * Triggers a `remove` event on the parent and a `dispose` event on itself.
+     * The widget can no longer be used.
+     */
+    dispose (): void;
+
+    /**
+     * Returns a (possibly empty) collection of all descendants of this widget.
+     */
+    find (): WidgetCollection
+
+    /**
+     * Returns a (possibly empty) collection of all descendants of this widget that match the selector.
+     * @param selector
+     */
+    find (selector: string): WidgetCollection
+
+    /**
+     * Returns `true` if the widget has been disposed, otherwise `false`.
+     */
+    isDisposed (): boolean
+
+    /**
+     * Returns the parent of this widget.
+     */
+    parent (): T;
+
+    /**
+     * An application-wide unique identifier automatically assigned to all widgets on creation.
+     * Do not change it.
+     */
+    cid: string;
+
+    /**
+     * Direct access to the value of the property of the same name.
+     * May be used instead of `widget.get("id");`.
+     * Do not use this field to change the value, instead use `widget.set("id", id);`.
+     */
+    id: string;
+
+    /**
+     * The exact string that was used to create this widget using the `tabris.create` method.
+     */
+    type: string;
+
+  }
+
+  interface WidgetProperties {
+
+    /**
+     * The background color of the widget.
+     */
+    background?: string;
+
+    /**
+     * An image to be displayed on the widget's background.
+     * If the image is smaller than the widget, it will be tiled.
+     */
+    backgroundImage?: Image;
+
+    /**
+     * The vertical position of the widget's baseline relative to a sibling widget.
+     */
+    baseline?: any;
+
+    /**
+     * The position of the widget's bottom edge relative to the parent or a sibling widget.
+     */
+    bottom?: any;
+
+    /**
+     * The actual location and size of the widget, relative to its parent. This property is read-only.
+     */
+    bounds?: Bounds;
+
+    /**
+     * The horizontal position of the widget's center relative to the parent's center.
+     */
+    centerX?: number;
+
+    /**
+     * The vertical position of the widget's center relative to the parent's center.
+     */
+    centerY?: number;
+
+    /**
+     * Whether the widget can be operated.
+     */
+    enabled?: boolean;
+
+    /**
+     * The font used for the widget.
+     */
+    font?: string;
+
+    /**
+     * The height of the widget.
+     */
+    height?: number;
+
+    /**
+     * Whether the entire widget should be highlighted while touched.
+     */
+    highlightOnTouch?: boolean;
+
+    /**
+     * A string to identify the widget by using selectors. Id's are optional.
+     * It is strongly recommended that they are unique within a page.
+     */
+    id?: string;
+
+    /**
+     * Shorthand for all layout properties. See [Layout](../layout.md).
+     */
+    layoutData?: Object;
+
+    /**
+     * The position of the widget's left edge relative to the parent or a sibling widget.
+     */
+    left?: any;
+
+    /**
+     * Opacity of the entire widget. Can be used for fade animations.
+     */
+    opacity?: number;
+
+    /**
+     * The position of the widget's right edge relative to the parent or a sibling widget.
+     */
+    right?: any;
+
+    /**
+     * Text color of the widget.
+     */
+    textColor?: string;
+
+    /**
+     * The position of the widget's top edge relative to the parent or a sibling widget.
+     */
+    top?: any;
+
+    /**
+     * Modifications to the widget's shape, size, or position. Can be used for animations.
+     * **Note:** In Android, the *transform* property does not affect the *bounds* property,
+     * while it does so in iOS.
+     */
+    transform?: Transformation;
+
+    /**
+     * Whether the widget is visible.
+     */
+    visible?: boolean;
+
+    /**
+     * The width of the widget.
+     */
+    width?: number;
+
+  }
+
+  // Action
+
+  function create (type: "Action", properties: ActionProperties): Action;
+
+  /**
+   * An executable item that is integrated in the application's navigation menu.
+   * Add a listener on *select* to implement the action.
+   */
+  interface Action extends Widget <Action> {
+
+    set (property: string, value: any, options?: Object): Action;
+    set (properties: ActionProperties, options?: Object): Action;
+
+  }
+
+  interface ActionProperties extends WidgetProperties {
+
+    /**
+     * Icon image for the action.
+     */
+    image?: Image;
+
+    /**
+     * Actions with higher placement priority will be placed at a more significant position in the UI,
+     * e.g. low priority actions could go into a menu instead of being included in a toolbar.
+     * Any of `low`, `high`, `normal`.
+     */
+    placementPriority?: string;
+
+    /**
+     * The text to be displayed for the action.
+     */
+    title?: string;
+
+  }
+
+  // Button
+
+  function create (type: "Button", properties: ButtonProperties): Button;
+
+  /**
+   * A push button. Can contain a text or an image.
+   */
+  interface Button extends Widget <Button> {
+
+    set (property: string, value: any, options?: Object): Button;
+    set (properties: ButtonProperties, options?: Object): Button;
+
+  }
+
+  interface ButtonProperties extends WidgetProperties {
+
+    /**
+     * The horizontal alignment of the button text.
+     * Any of `left`, `right`, `center`. Defaults to `center`.
+     */
+    alignment?: string;
+
+    /**
+     * An image to be displayed on the button.
+     */
+    image?: Image;
+
+    /**
+     * The button's label text.
+     */
+    text?: string;
+
+  }
+
+  // Canvas
+
+  function create (type: "Canvas", properties: WidgetProperties): Canvas;
+
+  /**
+   * Canvas is a widget which allows drawing on it using a canvas context.
+   * Canvas context is a subset of the HTML5 [CanvasRenderingContext2D](https://developer.mozilla.org/en/docs/Web/API/CanvasRenderingContext2D). 
+   */
+  interface Canvas extends Composite {
+
+    /**
+     * Returns the drawing context.
+     *
+     * @param contextType This must be `"2d"`
+     * @param width
+     * @param height
+     */
+    getContext (contextType: string, width: number, height: number): CanvasContext;
+
+  }
+
+  // Cell
+
+  function create (type: "Cell", properties: CellProperties): Cell;
+
+  /**
+   * This widget represents a space in a *CollectionView* on which an item is displayed.
+   * Cell widgets are not created by the application but by the *CollectionView* widget.
+   */
+  interface Cell extends Composite {
+
+    set (property: string, value: any, options?: Object): Cell;
+    set (properties: CellProperties, options?: Object): Cell;
+
+  }
+
+  interface CellProperties extends WidgetProperties {
+
+    /**
+     * The item that is currently represented by this cell.
+     * This property is not set by the application but by the *CollectionView* widget.
+     */
+    item?: any;
+
+    /**
+     * The index of the item that is currently represented by this cell.
+     * This property is not set by the application but by the *CollectionView* widget.
+     */
+    itemIndex?: number;
+
+  }
+
+  // CheckBox
+
+  function create (type: "CheckBox", properties: CheckBoxProperties): CheckBox;
+
+  /**
+   * A check box widget.
+   */
+  interface CheckBox extends Widget <CheckBox> {
+
+    set (property: string, value: any, options?: Object): CheckBox;
+    set (properties: CheckBoxProperties, options?: Object): CheckBox;
+
+  }
+
+  interface CheckBoxProperties extends WidgetProperties {
+
+    /**
+     * The checked state of the check box.
+     */
+    selection?: boolean;
+
+    /**
+     * The label text of the check box.
+     */
+    text?: string;
+
+  }
+
+  // CollectionView
+
+  function create (type: "CollectionView", properties: CollectionViewProperties): CollectionView;
+
+  /**
+   * A scrollable list that displays data items in cells, one per row.
+   * Cells are created on demand and filled with widgets in the *initializeCell* callback.
+   */
+  interface CollectionView extends Widget <CollectionView> {
+
+    set (property: string, value: any, options?: Object): CollectionView;
+    set (properties: CollectionViewProperties, options?: Object): CollectionView;
+
+    /**
+     * Inserts the given items into this view. Items are added at the end.
+     * This operation will modify the *items* property.
+     *
+     * @param items
+     */
+    insert (items: any[]): void;
+
+    /**
+     * Inserts the given items into this view at the given index.
+     * This operation will modify the *items* property.
+     *
+     * @param items
+     * @param index the position to insert the items at.
+     *   If a negative index is given, it is interpreted as relative to the end.
+     *   If the given index is greater than the item count, new items will be appended at the end. 
+     */
+    insert (items: any[], index: number): void;
+
+    /**
+     * Triggers a refresh of all visible items.
+     * This will issue *change:item* events on the corresponding cells.
+     */
+    refresh (): void;
+
+    /**
+     * Triggers a refresh of the item with the given index.
+     * If the item is scrolled into view, an *change:item* event will be issued on the corresponding cell.
+     *
+     * @param index The index of the item that was changed.
+     */
+    refresh (index: number): void;
+
+    /**
+     * Removes the item at the given index from this view. This operation will modify the *items* property.
+     * @param index The index of the item to remove. If this is negative, it is interpreted as relative to the end.
+     */
+    remove (index: number): void;
+
+    /**
+     * Removes *count* items beginning with the given index from this view.
+     * This operation will modify the *items* property.
+     *
+     * @param index The index of the first item to remove.
+     *   If this is negative, it is interpreted as relative to the end.
+     * @param count The number of items to remove.
+     */
+    remove (index: number, count: number): void;
+
+    /**
+     * Scrolls the item with the given index into view.
+     * @param index The index of the item to reveal. If this is negative, it is interpreted as relative to the end
+     */
+    reveal (index: number): void;
+
+  }
+
+  interface CollectionViewProperties extends WidgetProperties {
+
+    /**
+     * The name of the cell type to use for a given item.
+     * This name will be passed to the `initializeCell` and `itemHeight` functions.
+     * Cells will be reused only by items that require the same cell type.
+     * If set to a function, this function will be called for every item, providing the item as a parameter,
+     * and must return a name for the cell type to use for the given item.
+     */
+    cellType?: (item : any) => string | string;
+
+    /**
+     * A callback used to initialize a collection cell by attaching widget and *change:item* listener.
+     * Cells are created by the framework and recycled on scrolling.
+     * This callback receives the cell as the first and the cell type as second parameter.
+     *
+     * @static
+     */
+    initializeCell?: (cell: Cell, type: string) => any;
+
+    /**
+     * The height of a collection cell. If set to a function, this function will be called for every item,
+     * providing the item and the cell type as parameters, and must return the item height for the given item.
+     */
+    itemHeight?: (item: any, type: string) => number | number;
+
+    /**
+     * An array of data items to be displayed by the collection view.
+     * For dynamic content, use the methods `insert` and `remove` instead of setting this property directly.
+     */
+    items?: any[];
+
+    /**
+     * Enables the user to trigger a refresh by using the pull-to-refresh gesture.
+     */
+    refreshEnabled?: boolean;
+
+    /**
+     * Whether the refresh indicator is currently visible. Will be set to `true` when a *refresh* event
+     * is triggered. Reset it to `false` when the refresh is finished.
+     */
+    refreshIndicator?: boolean;
+
+    /**
+     * The message text displayed together with the refresh indicator. Currently not supported on Android.
+     */
+    refreshMessage?: string;
+
+  }
+
+  // Composite
+
+  function create (type: "Composite", properties: WidgetProperties): Composite;
+
+  interface Parent <T> {
+
+    /**
+     * Adds the given widget(s) in the given order to the composite.
+     *
+     * @param child
+     * @param child*
+     */
+    append (...children: Widget<any>[]): T;
+
+    /**
+     * Adds all widgets in the given collection to the composite.
+     * @param collection
+     */
+    append (collection: WidgetCollection): T;
+
+  }
+
+  /**
+   * An empty widget that can contain other widgets.
+   */
+  interface Composite extends Widget <Composite>, Parent <Composite> {
+  }
+
+  // Drawer
+
+  function create (type: "Drawer", properties: WidgetProperties): Drawer;
+
+  /**
+   * A navigation drawer that can be swiped in from the left edge of the screen. Can contain any kind of widgets.
+   * It may be useful to include a `PageSelector` that displays all top-level pages.
+   */
+  interface Drawer extends Composite {
+
+    /**
+     * Closes the drawer.
+     */
+    close (): Drawer;
+
+    /**
+     * Opens the drawer.
+     */
+    open (): Drawer;
+
+  }
+
+  // ImageView
+
+  function create (type: "ImageView", properties: ImageViewProperties): ImageView;
+
+  /**
+   * A widget to display an image.
+   */
+  interface ImageView extends Widget <ImageView> {
+
+    set (property: string, value: any, options?: Object): ImageView;
+    set (properties: ImageViewProperties, options?: Object): ImageView;
+
+  }
+
+  interface ImageViewProperties {
+
+    image?: Image;
+
+    /**
+     * Any of `auto`, `fit`, `fill`, `stretch`, `none`. Defaults to `auto`.;
+     */
+    scaleMode?: string;
+
+  }
+
+  // Page
+
+  function create (type: "Page", properties: PageProperties): Page;
+
+  /**
+   * Pages contain an application's UI. Top-level pages are included in the application's main menu.
+   */
+  interface Page extends Widget <Page>, Parent <Page> {
+
+    set (property: string, value: any, options?: Object): Page;
+    set (properties: PageProperties, options?: Object): Page;
+
+    /**
+     * Opens the page, i.e. makes it the active page.
+     */
+    open (): Page;
+
+    /**
+     * Closes and disposes of the page.
+     */
+    close (): void;
+
+  }
+
+  interface PageProperties extends WidgetProperties {
+
+    image?: Image;
+
+    title?: string;
+
+    topLevel?: boolean;
+
+  }
+
+  // PageSelector
+
+  function create (type: "PageSelector", properties: WidgetProperties): PageSelector;
+
+  /**
+   * A CollectionView that contains all top-level pages and allows to open them.
+   * New top-level pages are added dynamically.
+   */
+  interface PageSelector extends CollectionView {
+  }
+
+  // Picker
+
+  function create (type: "Picker", properties: PickerProperties): Picker;
+
+  /**
+   * A widget with a drop-down list of items to choose from.
+   */
+  interface Picker extends Widget <Picker> {
+
+    set (property: string, value: any, options?: Object): Picker;
+    set (properties: PickerProperties, options?: Object): Picker;
+
+  }
+
+  interface PickerProperties extends WidgetProperties {
+
+    items?: string[];
+
+    selection?: string;
+
+    selectionIndex?: number;
+
+  }
+
+  // ProgressBar
+
+  function create (type: "ProgressBar", properties: ProgressBarProperties): ProgressBar;
+
+  /**
+   * A widget representing a numeric value as a horizontal bar with a growing indicator.
+   */
+  interface ProgressBar extends Widget <ProgressBar> {
+
+    set (property: string, value: any, options?: Object): ProgressBar;
+    set (properties: ProgressBarProperties, options?: Object): ProgressBar;
+
+  }
+
+  interface ProgressBarProperties {
+
+    /**
+     * Defaults to 100.
+     */
+    maximum?: number;
+
+    /**
+     * Defaults to 0.
+     */
+    minimum?: number;
+
+    /**
+     * Defaults to 0.
+     */
+    selection?: number;
+
+    /**
+     * Any of `normal`, `paused, `error`. Defaults to `normal`.
+     */
+    state?: string;
+
+  }
+
+  // RadioButton
+
+  function create (type: "RadioButton", properties: RadioButtonProperties): RadioButton;
+
+  /**
+   * A radio button. Selecting a radio button de-selects all its siblings (i.e. all radio buttons
+   * within the same parent).
+   */
+  interface RadioButton extends Widget <RadioButton> {
+
+    set (property: string, value: any, options?: Object): RadioButton;
+    set (properties: RadioButtonProperties, options?: Object): RadioButton;
+
+  }
+
+  interface RadioButtonProperties extends WidgetProperties {
+
+    /**
+     * The checked state of the radio button.
+     */
+    selection?: boolean;
+
+    /**
+     * The label text of the radio button.
+     */
+    text?: string;
+
+  }
+
+  // ScrollView
+
+  function create (type: "ScrollView", properties: ScrollViewProperties): ScrollView;
+
+  /**
+   * A composite that allows its content to overflow either vertically (default) or horizontally.
+   * Children of a ScrollView may not be attached to its edge in scrolling direction (to the bottom
+   * for vertical scrolling, to the right for horizontal scrolling).
+   */
+  interface ScrollView extends Composite {
+
+    set (property: string, value: any, options?: Object): ScrollView;
+    set (properties: ScrollViewProperties, options?: Object): ScrollView;
+
+  }
+
+  interface ScrollViewProperties extends WidgetProperties {
+
+    /**
+     * Specifies the scrolling direction of the scroll composite.
+     * Either `vertical` or `horizontal`. Default to `vertical`.
+     * @static
+     */
+    direction?: string;
+
+  }
+
+  // SearchAction
+
+  function create (type: "SearchAction", properties: SearchActionProperties): SearchAction;
+
+  /**
+   * An action that displays a search text field with dynamic proposals when selected.
+   * Add a listener on *select* to implement the action. On *input*, you may set a list of *proposals*.
+   */
+  interface SearchAction extends Action {
+
+    set (property: string, value: any, options?: Object): SearchAction;
+    set (properties: SearchActionProperties, options?: Object): SearchAction;
+
+  }
+
+  interface SearchActionProperties extends ActionProperties {
+
+    /**
+     * A hint text that is displayed when the search input is empty.
+     */
+    message?: string;
+
+    /**
+     * The list of proposals to display.
+     */
+    proposals?: string[];
+
+    /**
+     * The text in the search input field.
+     */
+    text?: string;
+
+  }
+
+  // Slider
+
+  function create (type: "Slider", properties: SliderProperties): Slider;
+
+  /**
+   * A widget representing a numeric value as an movable indicator on a horizontal line.
+   */
+  interface Slider extends Widget <Slider> {
+
+    set (property: string, value: any, options?: Object): Slider;
+    set (properties: SliderProperties, options?: Object): Slider;
+
+  }
+
+  interface SliderProperties extends WidgetProperties {
+
+    maximum?: number;
+
+    minimum?: number;
+
+    selection?: number;
+
+  }
+
+  // Switch
+
+  function create (type: "Switch", properties: SwitchProperties): Switch;
+
+  /**
+   * A switch widget that can be toggled.
+   */
+  interface Switch extends Widget <Switch> {
+
+    set (property: string, value: any, options?: Object): Switch;
+    set (properties: SwitchProperties, options?: Object): Switch;
+
+  }
+
+  interface SwitchProperties extends WidgetProperties {
+
+    /**
+     * The checked state of the switch.
+     */
+    selection?: boolean;
+
+  }
+
+  // Tab
+
+  function create (type: "Tab", properties: TabProperties): Tab;
+
+  /**
+   * A container representing a single tab of the TabFolder widget.
+   */
+  interface Tab extends Composite {
+
+    set (property: string, value: any, options?: Object): Tab;
+    set (properties: TabProperties, options?: Object): Tab;
+
+  }
+
+  interface TabProperties extends WidgetProperties {
+
+    badge?: string;
+
+    image?: Image;
+
+    title?: string;
+
+  }
+
+  // TabFolder
+
+  function create (type: "TabFolder", properties: TabFolderProperties): TabFolder;
+
+  /**
+   * A widget that can switch between [tabs](#tab).
+   */
+  interface TabFolder extends Widget <TabFolder> {
+
+    set (property: string, value: any, options?: Object): TabFolder;
+    set (properties: TabFolderProperties, options?: Object): TabFolder;
+
+    /**
+     * Adds the given tabs in the given order to the TabFolder.
+     *
+     * @param children
+     */
+    append (...children: Tab[]): TabFolder;
+
+  }
+
+  interface TabFolderProperties extends WidgetProperties {
+
+    /**
+     * Enables swiping through tabs.
+     */
+    paging?: boolean;
+
+    selection?: Tab;
+
+    /**
+     * The placement of the tab titles. When set to `"auto"`, the position is platform dependent.
+     * Any of `top`, `bottom`, `auto`. Defaults to `auto`.
+     * @static
+     */
+    tabBarLocation?: string;
+
+  }
+
+  // TextInput
+
+  function create (type: "TextInput", properties: TextInputProperties): TextInput;
+
+  /**
+   * A widget that allows to enter text.
+   */
+  interface TextInput extends Widget <TextInput> {
+
+    set (property: string, value: any, options?: Object): TextInput;
+    set (properties: TextInputProperties, options?: Object): TextInput;
+
+  }
+
+  interface TextInputProperties extends WidgetProperties {
+
+    /**
+     * The horizontal alignment of the text.
+     * Any of `left`, `right`, `center`. Default: `left`.
+     */
+    alignment?: string;
+
+    /**
+     * Automatically switch to capital letters after every key pressed.
+     */
+    autoCapitalize?: boolean;
+
+    /**
+     * Enables the spell checker and auto-correction feature.
+     */
+    autoCorrect?: boolean;
+
+    editable?: boolean;
+
+    /**
+     * Selects the keyboard type to use for editing this widget.
+     * Any of `ascii`, `decimal`, `email`, `number`, `numbersAndPunctuation`, `phone`, `url`, `default`.
+     */
+    keyboard?: string;
+
+    /**
+     * A hint text that is displayed when the input field is empty.
+     */
+    message?: string;
+
+    /**
+     * The text in the input field.
+     */
+    text?: string;
+
+    /**
+     * The type of the text widget.
+     * Any of `default`, `password`, `search`, `multiline`.
+     * @static
+     */
+    type?: string;
+
+  }
+
+  // TextView
+
+  function create (type: "TextView", properties: TextViewProperties): TextView;
+
+  /**
+   * A widget to display a text. For images, use ImageView.
+   */
+  interface TextView extends Widget <TextView> {
+
+    set (property: string, value: any, options?: Object): TextView;
+    set (properties: TextViewProperties, options?: Object): TextView;
+
+  }
+
+  interface TextViewProperties extends WidgetProperties {
+
+    /**
+     * The horizontal alignment of the text.
+     * Any of `left`, `right`, `center`. Default: `left`.
+     */
+    alignment?: string;
+
+    /**
+     * Allows for a subset of HTML tags in the text.
+     * Supported tags are: `a`, `del`, `ins`, `b`, `i`, `strong`, `em`, `big`, `small`, `br`.
+     * All tags must be closed (e.g. use `<br/>` instead of `<br>`). Nesting tags is currently not supported.
+     * @static
+     */
+    markupEnabled?: boolean;
+
+    /**
+     * Limit the number of lines to be displayed to the given maximum. `null` disables this limit.
+     */
+    maxLines?: number;
+
+    /**
+     * The text to display.
+     */
+    text?: string;
+
+  }
+
+  // ToggleButton
+
+  function create (type: "ToggleButton", properties: ToggleButtonProperties): ToggleButton;
+
+  /**
+   * A push button that "snaps in", i.e. it is selected when pressed and deselected when pressed again.
+   */
+  interface ToggleButton extends Widget <ToggleButton> {
+
+    set (property: string, value: any, options?: Object): ToggleButton;
+    set (properties: ToggleButtonProperties, options?: Object): ToggleButton;
+
+  }
+
+  interface ToggleButtonProperties extends WidgetProperties {
+
+    /**
+     * The horizontal alignment of the button text.
+     * Any of `left`, `right`, `center`. Default: `left`.
+     */
+    alignment?: string;
+
+    /**
+     * An image to be displayed on the button.
+     */
+    image?: Image;
+
+    /**
+     * The selection state of the toggle button.
+     */
+    selection?: boolean;
+
+    /**
+     * The button's label text.
+     */
+    text?: string;
+
+  }
+
+  // Video
+
+  function create (type: "Video", properties: VideoProperties): Video;
+
+  /**
+   * A widget that plays a video from a URL.
+   */
+  interface Video extends Widget <Video> {
+
+    set (property: string, value: any, options?: Object): Video;
+    set (properties: VideoProperties, options?: Object): Video;
+
+  }
+
+  interface VideoProperties extends WidgetProperties {
+
+    /**
+     * The URL of the video to play.
+     */
+    url?: string;
+
+  }
+
+  // WebView
+
+  function create (type: "WebView", properties: WebViewProperties): WebView;
+
+  /**
+   * A widget that can display a web page.
+   * Since this widget requires a lot of recourses it's recommended to have no more than one instance at a time.
+   */
+  interface WebView extends Widget <WebView> {
+
+    set (property: string, value: any, options?: Object): Video;
+    set (properties: WebViewProperties, options?: Object): Video;
+
+  }
+
+  interface WebViewProperties extends WidgetProperties {
+
+    /**
+     * A complete HTML document to display. Always returns the last set value.
+     */
+    html?: string;
+
+    /**
+     * The URL of the web page to display. Returns empty string when content from *html* property is displayed.
+     */
+    url?: string;
+
+  }
+
+  // WidgetCollection
+
+  /**
+   */
+  interface WidgetCollection extends EventSupport <WidgetCollection> {
+
+    /**
+     * Animates all widgets in this collection.
+     *
+     * @param properties The properties and target values to animate.
+     * @param options Configures the animation itself.
+     */
+    animate (properties: WidgetProperties, options: AnimationOptions): void;
+
+    /**
+     * Append all widgets in this collection to the given widget.
+     * @param parent
+     */
+    appendTo (parent: Composite): WidgetCollection;
+
+    /**
+     * Returns a collection containing all children of all widgets in this collection.
+     */
+    children (): WidgetCollection;
+
+    /**
+     * Same as `collection.children().filter(selector)`.
+     * @param selector
+     */
+    children (selector: string): WidgetCollection;
+
+    /**
+     * Disposes all widgets in this collection.
+     */
+    dispose (): void;
+
+    /**
+     * Returns a collection containing all descendants of all widgets in this collection.
+     */
+    find (): WidgetCollection;
+
+    /**
+     * Returns a collection containing all descendants of all widgets in this collection that match the given selector.
+     * @param selector
+     */
+    find (selector: string): WidgetCollection;
+
+    /**
+     * Returns a collection containing all direct parents of all widgets in this collection.
+     */
+    parent (): WidgetCollection;
+
+    /**
+     * A read-only field containing the number of widgets in the collection.
+     */
+    length: number;
+
+  }
+
+  // tabris.app
+
+  /**
+   * The object `tabris.app` provides information about the application.
+   */
+  interface App {
+
+    /**
+     * Installs a patch from the given URL.
+     * When the patch is successfully installed, it will remain inactive until the application is reloaded.
+     * @param url The URL to fetch a patch from.
+     * @param callback A callback function to be called when the installation has finished or failed.
+     * In case of a failure, the callback will receive a parameter `error` that contains an Error object.
+     * If the installation succeeds, this parameter will be `undefined` and a second parameter will contain
+     * the parsed content of the file `patch.json` from the installed patch.
+     * @provisional
+     */
+    installPatch (url : string, callback : (error: Error, patch: Object) => any): void;
+
+    /**
+     * Forces the running application to reload the main module and start over.
+     */
+    reload (): void;
+
+  }
+
+  export var app: App;
+
+  // tabris.device
+
+  /**
+   * The object `tabris.device` provides information about the device that executes the application.
+   * All properties are read-only.
+   */
+  interface Device extends EventSupport <Device> {
+
+    get(property: string): void;
+
+    /**
+     * The user language configured on the device as an [RFC 4646](http://tools.ietf.org/html/rfc4646) compliant string. For example `"de"`, `"es-ES"`, etc. This property is also available globally as `navigator.language`.
+     */
+    get(property: "language"): string;
+
+    /**
+     * The name of the device model. For example `"iPad4,1"` or `"Nexus 7"`.
+     * This property is also available globally as `device.model`.
+     */
+    get(property: "model"): string;
+
+    /**
+     * The device orientation. One of `portrait-primary`, `portrait-secondary`, `landscape-primary`, and `landscape-secondary`.
+     */
+    get(property: "orientation"): string;
+
+    /**
+     * The name of the platform. Currently either `"Android"` or `"iOS"`.
+     * This property is also available globally as `device.platform`.
+     */
+    get(property: "platform"): string;
+
+    /**
+     * The ratio between physical pixels and device independent pixels.
+     * This property is also available globally as [`window.devicePixelRatio`](https://developer.mozilla.org/en-US/docs/Web/API/Window.devicePixelRatio).
+     */
+    get(property: "scaleFactor"): number;
+
+    /**
+     * The entire height of the device's screen in device independent pixel.
+     * Depends on the current device orientation. This property is also available globally as [screen.height](https://developer.mozilla.org/en-US/docs/Web/API/Screen.height).
+     */
+    get(property: "screenHeight"): number;
+
+    /**
+     * The entire width of the device's screen in device independent pixel.
+     * Depends on the current device orientation. This property is also available as globally as [screen.width](https://developer.mozilla.org/en-US/docs/Web/API/Screen.width).
+     */
+    get(property: "screenWidth"): number;
+
+    /**
+     * The platform version. On iOS it lools like this: `"8.1.1"`.
+     * On Android, the [version code](https://developer.android.com/reference/android/os/Build.VERSION_CODES.html)
+     * is returned. This property is also available globally as `device.version`.
+     */
+    get(property: "version"): string;
+
+  }
+
+  export var device: Device;
+
+  // tabris.ui
+
+  /**
+   * The object `tabris.ui` is the root element for all widgets.
+   * This is the parent for all top-level pages, *actions* and the *drawer*.
+   */
+  interface UI extends EventSupport <UI> {
+
+    get(property: string): void;
+
+    /**
+     * The currently visible page.
+     */
+    get(property: "activePage"): Page;
+
+    /**
+     * Background color for the navigation elements.
+     */
+    get(property: "background"): string;
+
+    /**
+     * Text color for the navigation elements.
+     */
+    get(property: "textColor"): string;
+
+    /**
+     * Whether the toolbars above and below pages are visible.
+     */
+    get(property: "toolbarVisible"): boolean;
+
+  }
+
+  export var ui: UI;
+
+}
+
+declare module "tabris" {
+  export = tabris;
+}