implab/implabjs-dojo-typings Commit - r2:1e22cac2aaf4

Added events map support to _WidgetBase, corrected attributes map support in _WidgetBase

cin -

r2:1e22cac2aaf4 v1.0.0-rc1 default

parent child

Context file:

r2:1e22cac2aaf4

Collapse all files

The requested changes are too big and content was truncated. Show full diff

dojo-typings/src/test/typings/traits.d.ts created 644 +25 0

			@@ -0,0 +1,25
		1	import * as _WidgetBase from "dijit/_WidgetBase";
		2	import * as Stateful from "dojo/Stateful";
		3
		4	export interface IRemovable {
		5	remove(): void;
		6	}
		7
		8	type StatefulAttrs<T> = T extends Stateful<infer A> ? A : never;
		9
		10	interface WatchFn {
		11	<T extends Stateful, K extends keyof StatefulAttrs<T>>(
		12	target: T,
		13	prop: K,
		14	render: (model: StatefulAttrs<T>[K]) => any,
		15	own?: (obj: IRemovable) => void
		16	);
		17	<W extends _WidgetBase, K extends keyof W>(
		18	target: W,
		19	prop: K,
		20	render: (model: W[K]) => any,
		21	own?: (obj: IRemovable) => void
		22	);
		23	}
		24
		25	export declare const watch: WatchFn;

dojo-typings/src/main/typings/dijit/dijit.d.ts 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

dojo-typings/src/main/typings/dijit/modules.d.ts +3 -3

              /// <reference path="index.d.ts" />
              declare module 'dijit/_Widget' {
              	type _Widget = dijit._Widget;
              	const _Widget: dijit._WidgetBaseConstructor<_Widget>;
              	export = _Widget;
              }
              declare module 'dijit/_WidgetBase' {
-             	type _WidgetBase<A = any> = dijit._WidgetBase<A>;
+             	type _WidgetBase<E extends { [k in keyof E]: Event } = {}> = dijit._WidgetBase<E & GlobalEventHandlersEventMap>;
                  // individual _WidgetBase constructor to keep type parameters
                  interface _WidgetBaseConstructor {
-                     new <A = any>(params?: Partial<_WidgetBase<A> & A>, srcNodeRef?: dojo.NodeOrString): _WidgetBase<A> & dojo._base.DeclareCreatedObject;
-                     prototype: _WidgetBase;
+                     new <A = {}, E extends { [k in keyof E]: Event } = {}>(params?: Partial<_WidgetBase<E> & A>, srcNodeRef?: dojo.NodeOrString): _WidgetBase<E> & dojo._base.DeclareCreatedObject;
+                     prototype: _WidgetBase<any>;
                  }
              	const _WidgetBase: _WidgetBaseConstructor;
              	export = _WidgetBase;
              }
              declare module 'dijit/_AttachMixin' {
              	type _AttachMixin = dijit._AttachMixin;
              	const _AttachMixin: dijit._AttachMixinConstructor;
              	export = _AttachMixin;
              }
              declare module 'dijit/_CssStateMixin' {
              	type _CssStateMixin = dijit._CssStateMixin;
              	const _CssStateMixin: dijit._CssStateMixinConstructor;
              	export = _CssStateMixin;
              }
              declare module 'dijit/_Contained' {
              	type _Contained = dijit._Contained;
              	const _Contained: dijit._ContainedConstructor;
              	export = _Contained;
              }
              declare module 'dijit/_Container' {
              	type _Container = dijit._Container;
              	const _Container: dijit._ContainerConstructor;
              	export = _Container;
              }
              declare module 'dijit/_KeyNavContainer' {
              	type _KeyNavContainer = dijit._KeyNavContainer;
              	const _KeyNavContainer: dijit._KeyNavContainerConstructor;
              	export = _KeyNavContainer;
              }
              declare module 'dijit/_KeyNavMixin' {
              	type _KeyNavMixin = dijit._KeyNavMixin;
              	const _KeyNavMixin: dijit._KeyNavMixinConstructor;
              	export = _KeyNavMixin;
              }
              declare module 'dijit/_MenuBase' {
              	type _MenuBase = dijit._MenuBase;
              	const _MenuBase: dijit._MenuBaseConstructor;
              	export = _MenuBase;
              }
              declare module 'dijit/_TemplatedMixin' {
              	type _TemplatedMixin = dijit._TemplatedMixin;
              	const _TemplatedMixin: dijit._TemplatedMixinConstructor;
              	export = _TemplatedMixin;
              }
              declare module 'dijit/_WidgetsInTemplateMixin' {
              	type _WidgetsInTemplateMixin = dijit._WidgetsInTemplateMixin;
              	const _WidgetsInTemplateMixin: dijit._WidgetsInTemplateMixinConstructor;
              	export = _WidgetsInTemplateMixin;
              }
              declare module 'dijit/ConfirmDialog' {
              	type ConfirmDialog = dijit.ConfirmDialog;
              	const ConfirmDialog: dijit.ConfirmDialogConstructor;
              	export = ConfirmDialog;
              }
              declare module 'dijit/Calendar' {
              	type Calendar = dijit.Calendar;
              	const Calendar: dijit.CalendarConstructor;
              	export = Calendar;
              }
              declare module 'dijit/CalendarLite' {
              	type CalendarLite = dijit.CalendarLite;
              	const CalendarLite: dijit.CalendarLiteConstructor;
              	export = CalendarLite;
              }
              declare module 'dijit/Destroyable' {
              	type Destroyable = dijit.Destroyable;
              	const Destroyable: dijit.DestroyableConstructor;
              	export = Destroyable;
              }
              declare module 'dijit/Dialog' {
              	type Dialog = dijit.Dialog;
              	const Dialog: dijit.DialogConstructor;
              	export = Dialog;
              }
              declare module 'dijit/DropDownMenu' {
              	type DropDownMenu = dijit.DropDownMenu;
              	const DropDownMenu: dijit.DropDownMenuConstructor;
              	export = DropDownMenu;
              }
              declare module 'dijit/Fieldset' {
              	type Fieldset = dijit.Fieldset;
              	const Fieldset: dijit.FieldsetConstructor;
              	export = Fieldset;
              }
              declare module 'dijit/Menu' {
              	type Menu = dijit.Menu;
              	const Menu: dijit.MenuConstructor;
              	export = Menu;
              }
              declare module 'dijit/MenuBar' {
              	type MenuBar = dijit.MenuBar;
              	const MenuBar: dijit.MenuBarConstructor;
              	export = MenuBar;
              }
              declare module 'dijit/MenuBarItem' {
              	type MenuBarItem = dijit.MenuBarItem;
              	const MenuBarItem: dijit.MenuBarItemConstructor;
              	export = MenuBarItem;
              }
              declare module 'dijit/MenuItem' {
              	type MenuItem = dijit.MenuItem;
              	const MenuItem: dijit.MenuItemConstructor;
              	export = MenuItem;
              }
              declare module 'dijit/MenuSeparator' {
              	type MenuSeparator = dijit.MenuSeparator;
              	const MenuSeparator: dijit.MenuSeparatorConstructor;
              	export = MenuSeparator;
              }
              declare module 'dijit/place' {
              	const place: dijit.Place;
              	export = place;
              }
              declare module 'dijit/popup' {
              	const popup: dijit.PopupManager;
              	export = popup;
              }
              declare module 'dijit/PopupMenuBarItem' {
              	type PopupMenuBarItem = dijit.PopupMenuBarItem;
              	const PopupMenuBarItem: dijit.PopupMenuBarItemConstructor;
              	export = PopupMenuBarItem;
              }
              declare module 'dijit/PopupMenuItem' {
              	type PopupMenuItem = dijit.PopupMenuItem;
              	const PopupMenuItem: dijit.PopupMenuItemConstructor;
              	export = PopupMenuItem;
              }
              declare module 'dijit/registry' {
              	const registry: dijit.Registry;
              	export = registry;
              }
              declare module 'dijit/TitlePane' {
              	type TitlePane = dijit.TitlePane;
              	const TitlePane: dijit.TitlePaneConstructor;
              	export = TitlePane;
              }
              declare module 'dijit/Toolbar' {
              	type Toolbar = dijit.Toolbar;
              	const Toolbar: dijit.ToolbarConstructor;
              	export = Toolbar;
              }
              declare module 'dijit/ToolbarSeparator' {
              	type ToolbarSeparator = dijit.ToolbarSeparator;
              	const ToolbarSeparator: dijit.ToolbarSeparatorConstructor;
              	export = ToolbarSeparator;
              }
              declare module 'dijit/Tooltip' {
              	type Tooltip = dijit.Tooltip;
              	const Tooltip: dijit.TooltipConstructor;
              	export = Tooltip;
              }
              declare module 'dijit/TooltipDialog' {
              	type TooltipDialog = dijit.TooltipDialog;
              	const TooltipDialog: dijit.TooltipDialogConstructor;
              	export = TooltipDialog;
              }
              declare module 'dijit/_base/focus' {
              	const focus: dijit._base.Focus;
              	export = focus;
              }
              declare module 'dijit/_base/manager' {
              	const manager: dijit._base.Manager;
              	export = manager;
              }
              declare module 'dijit/_base/place' {
              	const place: dijit._base.Place;
              	export = place;
              }
              declare module 'dijit/_base/popup' {
              	const popup: dijit._base.Popup;
              	export = popup;
              }
              declare module 'dijit/_base/scroll' {
              	const scroll: dijit._base.Scroll;
              	export = scroll;
              }
              declare module 'dijit/_base/sniff' {
              	const sniff: dijit._base.Sniff;
              	export = sniff;
              }
              declare module 'dijit/_base/typematic' {
              	const typematic: dijit._base.Typematic;
              	export = typematic;
              }
              declare module 'dijit/_base/wai' {
              	const wai: dijit._base.Wai;
              	export = wai;
              }
              declare module 'dijit/_base/window' {
              	const window: dijit._base.Window;
              	export = window;
              }
              declare module 'dijit/form/_FormMixin' {
              	type _FormMixin = dijit.form._FormMixin;
              	const _FormMixin: dijit.form._FormMixinConstructor;
              	export = _FormMixin;
              }
              declare module 'dijit/form/_FormValueWidget' {
              	type _FormValueWidget = dijit.form._FormValueWidget;
              	const _FormValueWidget: dijit.form._FormValueWidgetConstructor;
              	export = _FormValueWidget;
              }
              declare module 'dijit/form/_FormWidget' {
              	type _FormWidget = dijit.form._FormWidget;
              	const _FormWidget: dijit.form._FormWidgetConstructor;
              	export = _FormWidget;
              }
              declare module 'dijit/form/Button' {
              	type Button = dijit.form.Button;
              	const Button: dijit.form.ButtonConstructor;
              	export = Button;
              }
              declare module 'dijit/form/CheckBox' {
              	type CheckBox = dijit.form.CheckBox;
              	const CheckBox: dijit.form.CheckBoxConstructor;
              	export = CheckBox;
              }
              declare module 'dijit/form/ComboBox' {
              	type ComboBox = dijit.form.TextBox;
              	const ComboBox: dijit.form.ComboBoxConstructor;
              	export = ComboBox;
              }
              declare module 'dijit/form/ComboBoxMixin' {
              	type ComboBoxMixin<T, U extends dojo.store.api.BaseQueryType, V> = dijit.form.ComboBoxMixin<T, U, V>;
              	const ComboBoxMixin: dijit.form.ComboBoxConstructor;
              	export = ComboBoxMixin;
              }
              declare module 'dijit/form/CurrencyTextBox' {
              	type CurrencyTextBox = dijit.form.CurrencyTextBox;
              	const CurrencyTextBox: dijit.form.CurrencyTextBoxConstructor;
              	export = CurrencyTextBox;
              }
              declare module 'dijit/form/DataList' {
              	type DataList<T> = dijit.form.DataList<T>;
              	const DataList: dijit.form.DataListConstructor;
              	export = DataList;
              }
              declare module 'dijit/form/DateTextBox' {
              	type DateTextBox = dijit.form.DateTextBox;
              	const DateTextBox: dijit.form.DateTextBoxConstructor;
              	export = DateTextBox;
              }
              declare module 'dijit/form/DropDownButton' {
              	type DropDownButton<T extends dijit._WidgetBase> = dijit.form.DropDownButton<T>;
              	const DropDownButton: dijit.form.DropDownButtonConstructor;
              	export = DropDownButton;
              }
              declare module 'dijit/form/FilteringSelect' {
              	type FilteringSelect<C extends dijit.form.Constraints, T extends Object, Q extends string | Object | Function, O extends dojo.store.api.QueryOptions> = dijit.form.FilteringSelect<C, T, Q, O>;
              	const FilteringSelect: dijit.form.FilteringSelectConstructor;
              	export = FilteringSelect;
              }
              declare module 'dijit/form/Form' {
              	type Form = dijit.form.Form;
              	const Form: dijit.form.FormConstructor;
              	export = Form;
              }
              declare module 'dijit/form/HorizontalRule' {
              	type HorizontalRule = dijit.form.HorizontalRule;
              	const HorizontalRule: dijit.form.HorizontalRuleConstructor;
              	export = HorizontalRule;
              }
              declare module 'dijit/form/HorizontalRuleLabels' {
              	type HorizontalRuleLabels = dijit.form.HorizontalRuleLabels;
              	const HorizontalRuleLabels: dijit.form.HorizontalRuleLabelsConstructor;
              	export = HorizontalRuleLabels;
              }
              declare module 'dijit/form/HorizontalSlider' {
              	type HorizontalSlider = dijit.form.HorizontalSlider;
              	const HorizontalSlider: dijit.form.HorizontalSliderConstructor;
              	export = HorizontalSlider;
              }
              declare module 'dijit/form/MappedTextBox' {
              	type MappedTextBox<C extends dijit.form.Constraints> = dijit.form.MappedTextBox<C>;
              	const MappedTextBox: dijit.form.MappedTextBoxConstructor;
              	export = MappedTextBox;
              }
              declare module 'dijit/form/NumberSpinner' {
              	type NumberSpinner = dijit.form.NumberSpinner;
              	const NumberSpinner: dijit.form.NumberSpinnerConstructor;
              	export = NumberSpinner;
              }
              declare module 'dijit/form/NumberTextBox' {
              	type NumberTextBox = dijit.form.NumberTextBox;
              	const NumberTextBox: dijit.form.NumberTextBoxConstructor;
              	export = NumberTextBox;
              }
              declare module 'dijit/form/RadioButton' {
              	type RadioButton = dijit.form.RadioButton;
              	const RadioButton: dijit.form.RadioButtonConstructor;
              	export = RadioButton;
              }
              declare module 'dijit/form/RangeBoundTextBox' {
              	type RangeBoundTextBox = dijit.form.RangeBoundTextBox;
              	const RangeBoundTextBox: dijit.form.RangeBoundTextBoxConstructor;
              	export = RangeBoundTextBox;
              }
              declare module 'dijit/form/Select' {
              	type Select<T, Q extends dojo.store.api.BaseQueryType, O, U extends dijit._WidgetBase> = dijit.form.Select<T, Q, O, U>;
              	const Select: dijit.form.SelectConstructor;
              	export = Select;
              }
              declare module 'dijit/form/SimpleTextarea' {
              	type SimpleTextarea = dijit.form.SimpleTextarea;
              	const SimpleTextarea: dijit.form.SimpleTextareaConstructor;
              	export = SimpleTextarea;
              }
              declare module 'dijit/form/Textarea' {
              	type Textarea = dijit.form.Textarea;
              	const Textarea: dijit.form.TextareaConstructor;
              	export = Textarea;
              }
              declare module 'dijit/form/TextBox' {
              	type TextBox = dijit.form.TextBox;
              	const TextBox: dijit.form.TextBoxConstructor;
              	export = TextBox;
              }
              declare module 'dijit/form/ToggleButton' {
              	type ToggleButton = dijit.form.ToggleButton;
              	const ToggleButton: dijit.form.ToggleButtonConstructor;
              	export = ToggleButton;
              }
              declare module 'dijit/form/ValidationTextBox' {
              	type ValidationTextBox<C extends dijit.form.Constraints> = dijit.form.ValidationTextBox<C>;
              	const ValidationTextBox: dijit.form.ValidationTextBoxConstructor;
              	export = ValidationTextBox;
              }
              declare module 'dijit/layout/_LayoutWidget' {
              	type _LayoutWidget = dijit.layout._LayoutWidget;
              	const _LayoutWidget: dijit.layout._LayoutWidgetConstructor;
              	export = _LayoutWidget;
              }
              declare module 'dijit/layout/AccordionContainer' {
              	type AccordionContainer = dijit.layout.AccordionContainer;
              	const AccordionContainer: dijit.layout.AccordionContainerConstructor;
              	export = AccordionContainer;
              }
              declare module 'dijit/layout/AccordionPane' {
              	type AccordionPane = dijit.layout.AccordionPane;
              	const AccordionPane: dijit.layout.AccordionPaneConstructor;
              	export = AccordionPane;
              }
              declare module 'dijit/layout/ContentPane' {
              	type ContentPane = dijit.layout.ContentPane;
              	const ContentPane: dijit.layout.ContentPaneConstructor;
              	export = ContentPane;
              }
              declare module 'dijit/layout/_ContentPaneResizeMixin' {
              	type _ContentPaneResizeMixin = dijit.layout._ContentPaneResizeMixin;
              	const _ContentPaneResizeMixin: dijit.layout._ContentPaneResizeMixinConstructor;
              	export = _ContentPaneResizeMixin;
              }
              declare module 'dijit/layout/BorderContainer' {
              	type BorderContainer = dijit.layout.BorderContainer;
              	const BorderContainer: dijit.layout.BorderContainerConstructor;
              	export = BorderContainer;
              }
              declare module 'dijit/layout/LayoutContainer' {
              	type LayoutContainer = dijit.layout.LayoutContainer;
              	const LayoutContainer: dijit.layout.LayoutContainerConstructor;
              	export = LayoutContainer;
              }
              declare module 'dijit/layout/LinkPane' {
              	type LinkPane = dijit.layout.LinkPane;
              	const LinkPane: dijit.layout.LinkPaneConstructor;
              	export = LinkPane;
              }
              declare module 'dijit/layout/ScrollingTabController' {
              	type ScrollingTabController = dijit.layout.ScrollingTabController;
              	const ScrollingTabController: dijit.layout.ScrollingTabControllerConstructor;
              	export = ScrollingTabController;
              }
              declare module 'dijit/layout/StackContainer' {
              	type StackContainer = dijit.layout.StackContainer;
              	const StackContainer: dijit.layout.StackContainerConstructor;
              	export = StackContainer;
              }
              declare module 'dijit/layout/StackController' {
              	type StackController = dijit.layout.StackController;
              	const StackController: dijit.layout.StackControllerConstructor;
              	export = StackController;
              }
              declare module 'dijit/layout/TabContainer' {
              	type TabContainer = dijit.layout.TabContainer;
              	const TabContainer: dijit.layout.TabContainerConstructor;
              	export = TabContainer;
              }
              declare module 'dijit/layout/TabController' {
              	type TabController = dijit.layout.TabController;
              	const TabController: dijit.layout.TabControllerConstructor;
              	export = TabController;
              }

dojo-typings/src/main/typings/dojo/dojo.d.ts +1 -1

              /// <reference path="index.d.ts" />
              /// <reference path="../doh/doh.d.ts" />
              declare namespace dojo {
              	/* general implied types */
              	type NodeOrString = Node | string;
              	type ElementOrString = Element | string;
              	type NodeFragmentOrString = NodeOrString | DocumentFragment;
              	interface GenericConstructor<T> {
              		new (...args: any[]): T;
              		prototype: T;
              	}
              	interface GenericObject {
              		[id: string]: any;
              	}
              	interface GenericFunction<T> {
              		(...args: any[]): T;
              	}
              	interface Handle {
              		remove(): void;
              	}
              	interface EventListener {
              		(evt: any): void;
              	}
              	interface BuildProfile {
              		resourceTags: { [tag: string]: (filename: string, mid?: string) => boolean; };
              	}
              	interface Package {
              		location?: string;
              		main?: string;
              		name?: string;
              	}
              	export interface ModuleMap extends ModuleMapItem {
              		[ sourceMid: string ]: ModuleMapReplacement;
              	}
              	export interface ModuleMapItem {
              		[ mid: string ]: /* ModuleMapReplacement | ModuleMap */ any;
              	}
              	export interface ModuleMapReplacement extends ModuleMapItem {
              		[ findMid: string ]: /* replaceMid */ string;
              	}
              	/* dojo/AdapterRegistry */
              	interface AdapterRegistry {
              		/**
              		 * register a check function to determine if the wrap function or
              		 * object gets selected
              		 */
              		register(name: string, check: (...args: any[]) => boolean, wrap: Function, directReturn?: boolean, override?: boolean): void;
              		/**
              		 * Find an adapter for the given arguments. If no suitable adapter
              		 * is found, throws an exception. match() accepts any number of
              		 * arguments, all of which are passed to all matching functions
              		 * from the registered pairs.
              		 */
              		match(...args: any[]): any;
              		/**
              		 * Remove a named adapter from the registry
              		 */
              		unregister(name: string): boolean;
              	}
              	interface AdapterRegistryConstructor {
              		new (returnWrappers?: boolean): AdapterRegistry;
              		prototype: AdapterRegistry;
              	}
              	/* dojo/aspect */
              	interface AfterAdvice<T> {
              		(result: T, ...args: any[]): T;
              	}
              	interface AroundAdvice<T> {
              		(origFn: GenericFunction<T>): (...args: any[]) => T;
              	}
              	interface BeforeAdvice {
              		(...args: any[]): any[] | void;
              	}
              	interface Aspect {
              		/**
              		 * The "before" export of the aspect module is a function that can be used to attach
              		 * "before" advice to a method. This function will be executed before the original attach
              		 * is executed. This function will be called with the arguments used to call the mattach
              		 * This function may optionally return an array as the new arguments to use tattach
              		 * the original method (or the previous, next-to-execute before advice, if one exattach
              		 * If the before method doesn't return anything (returns undefined) the original argattach
              		 * will be presattach
              		 * If there are multiple "before" advisors, they are executed in the reverse order they were registered.
              		 */
              		before<T>(target: GenericObject, methodName: string, advice: BeforeAdvice | Function): Handle;
              		/**
              		 * The "around" export of the aspect module is a function that can be used to attach
              		 * "around" advice to a method. The advisor function is immediately executeattach
              		 * the around() is called, is passed a single argument that is a function that attach
              		 * called to continue execution of the original method (or the next around advattach
              		 * The advisor function should return a function, and this function will be called whattach
              		 * the method is called. It will be called with the arguments used to call the mattach
              		 * Whatever this function returns will be returned as the result of the method call (unless after advise changes it).
              		 */
              		around<T>(target: GenericObject, methodName: string, advice: AroundAdvice<T> | Function): Handle;
              		/**
              		 * The "after" export of the aspect module is a function that can be used to attach
              		 * "after" advice to a method. This function will be executed after the original method
              		 * is executed. By default the function will be called with a single argument, the return
              		 * value of the original method, or the the return value of the last executed advice (if a previous one exists).
              		 * The fourth (optional) argument can be set to true to so the function receives the original
              		 * arguments (from when the original method was called) rather than the return value.
              		 * If there are multiple "after" advisors, they are executed in the order they were registered.
              		 */
              		after<T>(target: GenericObject, methodName: string, advice: AfterAdvice<T> | Function, receiveArguments?: boolean): Handle;
              	}
              	/* dojo/back */
              	interface BackArgs {
              		back?: GenericFunction<void>;
              		forward?: GenericFunction<void>;
              		changeUrl?: boolean | string;
              	}
              	interface Back {
              		getHash(): string;
              		setHash(h: string): void;
              		/**
              		 * private method. Do not call this directly.
              		 */
              		goBack(): void;
              		/**
              		 * private method. Do not call this directly.
              		 */
              		goForward(): void;
              		/**
              		 * Initializes the undo stack. This must be called from a <script>
              		 * block that lives inside the `<body>` tag to prevent bugs on IE.
              		 * Only call this method before the page's DOM is finished loading. Otherwise
              		 * it will not work. Be careful with xdomain loading or djConfig.debugAtAllCosts scenarios,
              		 * in order for this method to work, dojo/back will need to be part of a build layer.
              		 */
              		init(): void;
              		/**
              		 * Sets the state object and back callback for the very first page
              		 * that is loaded.
              		 * It is recommended that you call this method as part of an event
              		 * listener that is registered via dojo/ready.
              		 */
              		setInitialState(args: BackArgs): void;
              		/**
              		 * adds a state object (args) to the history list.
              		 */
              		addToHistory(args: BackArgs): void;
              		/**
              		 * private method. Do not call this directly.
              		 */
              		_iframeLoaded(evt: Event, ifrLoc: Location): void;
              	}
              	/* dojo/behavior */
              	interface Behavior {
              		_behaviors: { [selector: string]: any };
              		/**
              		 * Add the specified behavior to the list of behaviors, ignoring existing
              		 * matches.
              		 */
              		add(behaviorObject: { [selector: string]: any }): void;
              		/**
              		 * Applies all currently registered behaviors to the document.
              		 */
              		apply(): void;
              	}
              	/* dojo/cookie */
              	interface CookieProps {
              		expires?: Date | string | number;
              		path?: string;
              		domain?: string;
              		secure?: boolean;
              	}
              	interface Cookie {
              		/* Get or set a cookie. */
              		(name: string, value?: string, props?: CookieProps): string;
              		/**
              		 * Use to determine if the current browser supports cookies or not.
              		 */
              		isSupported(): boolean;
              	}
              	/* dojo/currency */
              	interface CurrencyFormatOptions extends NumberFormatOptions {
              		/**
              		 * Should not be set.  Value is assumed to be "currency".
              		 */
              		type?: string;
              		/**
              		 * localized currency symbol. The default will be looked up in table of supported currencies in `dojo.cldr`
              		 * A [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code will be used if not found.
              		 */
              		symbol?: string;
              		/**
              		 * an [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code, a three letter sequence like "USD".
              		 * For use with dojo.currency only.
              		 */
              		currency?: string;
              		/**
              		 * number of decimal places to show.  Default is defined based on which currency is used.
              		 */
              		places?: number;
              	}
              	interface CurrencyParseOptions extends NumberParseOptions {
              		/**
              		 * Should not be set.  Value is assumed to be "currency".
              		 */
              		type?: string;
              		/**
              		 * localized currency symbol. The default will be looked up in table of supported currencies in `dojo.cldr`
              		 * A [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code will be used if not found.
              		 */
              		symbol?: string;
              		/**
              		 * an [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code, a three letter sequence like "USD".
              		 * For use with dojo.currency only.
              		 */
              		currency?: string;
              		/**
              		 * number of decimal places to show.  Default is defined based on which currency is used.
              		 */
              		places?: number;
              		/**
              		 * Whether to include the fractional portion, where the number of decimal places are implied by the currency
              		 * or explicit 'places' parameter.  The value [true,false] makes the fractional portion optional.
              		 * By default for currencies, it the fractional portion is optional.
              		 */
              		fractional?: boolean | [boolean, boolean];
              	}
              	interface Currency {
              		_mixInDefaults(options: NumberFormatOptions): CurrencyFormatOptions;
              		/**
              		 * Format a Number as a currency, using locale-specific settings
              		 */
              		format(value: number, options?: CurrencyFormatOptions): string;
              		/**
              		 * Builds the regular needed to parse a currency value
              		 */
              		regexp(options?: NumberRegexpOptions): string;
              		/**
              		 * Convert a properly formatted currency string to a primitive Number,
              		 * using locale-specific settings.
              		 */
              		parse(expression: string, options?: CurrencyParseOptions): number;
              	}
              	/* dojo/debounce */
              	interface Debounce {
              		/**
              		 * Create a function that will only execute after `wait` milliseconds
              		 */
              		<T extends Function>(cb: T, wait: number): T;
              		<T extends Function>(cb: Function, wait: number, ...args: any[]): T;
              	}
              	/* dojo/Deferred */
              	interface Deferred<T> {
              		/**
              		 * The public promise object that clients can add callbacks to.
              		 */
              		promise: promise.Promise<T>;
              		/**
              		 * Checks whether the deferred has been resolved.
              		 */
              		isResolved(): boolean;
              		/**
              		 * Checks whether the deferred has been rejected.
              		 */
              		isRejected(): boolean;
              		/**
              		 * Checks whether the deferred has been resolved or rejected.
              		 */
              		isFulfilled(): boolean;
              		/**
              		 * Checks whether the deferred has been canceled.
              		 */
              		isCanceled(): boolean;
              		/**
              		 * Emit a progress update on the deferred.
              		 */
              		progress(update: any, strict?: boolean): promise.Promise<T>;
              		/**
              		 * Resolve the deferred.
              		 */
              		resolve(value?: T, strict?: boolean): promise.Promise<T>;
              		/**
              		 * Reject the deferred.
              		 */
              		reject(error?: any, strict?: boolean): promise.Promise<T>;
              		/**
              		 * Add new callbacks to the deferred.
              		 */
              		then<U>(callback?: promise.PromiseCallback<T, U>, errback?: promise.PromiseErrback<U>, progback?: promise.PromiseProgback): promise.Promise<U>;
              		/**
              		 * Inform the deferred it may cancel its asynchronous operation.
              		 */
              		cancel(reason?: any, strict?: boolean): any;
              		/**
              		 * Returns `[object Deferred]`.
              		 */
              		toString(): string;
              	}
              	interface DeferredConstructor {
              		/**
              		 * Creates a new deferred. This API is preferred over
              		 * `dojo/_base/Deferred`.
              		 */
              		new <T>(canceller?: (reason: any) => void): Deferred<T>;
              		prototype: Deferred<any>;
              	}
              	/* dojo/DeferredList */
              	interface DeferredList<T> extends Deferred<T[]> {
              		/**
              		 * Gathers the results of the deferreds for packaging
              		 * as the parameters to the Deferred Lists' callback
              		 */
              		gatherResults<T>(deferredList: DeferredList<any>): DeferredList<T>;
              	}
              	interface DeferredListConstructor {
              		/**
              		 * Deprecated, use dojo/promise/all instead.
              		 * Provides event handling for a group of Deferred objects.
              		 */
              		new <T>(list: T[], fireOnOneCallback?: boolean, fireOnOneErrback?: boolean, consumeErrors?: boolean, canceller?: (reason: any) => void): DeferredList<T>;
              		prototype: DeferredList<any>;
              	}
              	/* dojo/dojo */
              	interface RequireTrace {
              		(group: string, args: any[]): void;
              		on: boolean | number;
              		group: GenericObject;
              		set(group: string | GenericObject, value: any): void;
              	}
              	interface Require {
              		(config: GenericObject, dependencies: string[], callback?: GenericFunction<void>): Require;
              		(dependencies: string[], callback: GenericFunction<void>): Require;
              		async: number| boolean;
              		has: dojo.Has;
              		isXdurl(url: string): boolean;
              		initSyncLoader(dojoRequirePlugin: any, checkDojoRequirePlugin: any, transformToAmd: any): GenericObject;
              		getXhr(): XMLHttpRequest | ActiveXObject;
              		getText(url: string, async?: boolean, onLoad?: (responseText: string, async?: boolean) => void): string;
              		eval(text: string, hint?: string): any;
              		signal(type: string, args: any[]): void;
              		on(type: string, listener: (...args: any[]) => void): Handle;
              		map: { [id: string]: any };
              		waitms?: number;
              		legacyMode: boolean;
              		rawConfig: dojo._base.Config;
              		baseUrl: string;
              		combo?: {
              			add: () => void;
              			done(callback: (mids: string[], url?: string) => void, req: Require): void;
              			plugins?: GenericObject;
              		};
              		idle(): boolean;
              		toAbsMid(mid: string, referenceModule?: string): string;
              		toUrl(name: string, referenceModule?: string): string;
              		undef(moduleId: string, referenceModule?: string): void;
              		pageLoaded: number | boolean;
              		injectUrl(url: string, callback?: () => void, owner?: HTMLScriptElement): HTMLScriptElement;
              		log(...args: any[]): void;
              		trace: RequireTrace;
              		boot?: [string[], Function] | number;
              	}
              	interface Define {
              		(mid: string, dependencies?: string[], factory?: any): void;
              		(dependencies: string[], factory?: any): void;
              		amd: string;
              	}
              	/* dojo/dom */
              	interface Dom {
              		/**
              		 * Returns DOM node with matching `id` attribute or falsy value (ex: null or undefined)
              		 * if not found. Internally if `id` is not a string then `id` returned.
              		 */
              		byId<E extends Element>(id: string | E, doc?: Document): E;
              		/**
              		 * Returns true if node is a descendant of ancestor
              		 */
              		isDescendant(node: NodeOrString, ancestor: NodeOrString): boolean;
              		/**
              		 * Enable or disable selection on a node
              		 */
              		setSelectable(node: ElementOrString, selectable?: boolean): void;
              	}
              	/* dojo/dom-attr */
              	interface DomAttr {
              		/**
              		 * Returns true if the requested attribute is specified on the
              		 * given element, and false otherwise.
              		 */
              		has(node: NodeOrString, name: string): boolean;
              		/**
              		 * Gets an attribute on an HTML element.
              		 * Because sometimes this uses node.getAttribute, it should be a string,
              		 * but it can also get any other attribute on a node, therefore it is unsafe
              		 * to type just a string.
              		 */
              		get(node: ElementOrString, name: string): any;
              		/**
              		 * Sets an attribute on an HTML element.
              		 */
              		set(node: ElementOrString, name: string, value: any): Element;
              		set(node: ElementOrString, map: GenericObject): Element;
              		/**
              		 * Removes an attribute from an HTML element.
              		 */
              		remove(node: NodeOrString, name: string): void;
              		/**
              		 * Returns an effective value of a property or an attribute.
              		 */
              		getNodeProp(node: NodeOrString, name: string): any;
              	}
              	/* dojo/dom-class */
              	interface DomClass {
              		/**
              		 * Returns whether or not the specified classes are a portion of the
              		 * class list currently applied to the node.
              		 */
              		contains(node: NodeOrString, classStr: string): boolean;
              		/**
              		 * Adds the specified classes to the end of the class list on the
              		 * passed node. Will not re-apply duplicate classes.
              		 */
              		add(node: NodeOrString, classStr: string | string[]): void;
              		/**
              		 * Removes the specified classes from node. No `contains()`
              		 * check is required.
              		 */
              		remove(node: NodeOrString, classStr?: string | string[]): void;
              		/**
              		 * Replaces one or more classes on a node if not present.
              		 * Operates more quickly than calling dojo.removeClass and dojo.addClass
              		 */
              		replace(node: NodeOrString, addClassStr: string | string[], removeClassStr?: string | string[]): void;
              		/**
              		 * Adds a class to node if not present, or removes if present.
              		 * Pass a boolean condition if you want to explicitly add or remove.
              		 * Returns the condition that was specified directly or indirectly.
              		 */
              		toggle(node: NodeOrString, classStr: string | string[], condition?: boolean): boolean;
              	}
              	/* dojo/dom-construct */
              	/* TODO implement for TS 1.8 */
              	/* type PosString = 'first' | 'after' | 'before' | 'last' | 'replace' | 'only'; */
              	interface DomConstruct {
              		/**
              		 * instantiates an HTML fragment returning the corresponding DOM.
              		 */
              		toDom(frag: string, doc?: Document): DocumentFragment | Node;
              		/**
              		 * Attempt to insert node into the DOM, choosing from various positioning options.
              		 * Returns the first argument resolved to a DOM node.
              		 */
              		place(node: NodeFragmentOrString, refNode: NodeOrString, position?: string /* PosString */ | number): HTMLElement;
              		/**
              		 * Create an element, allowing for optional attribute decoration
              		 * and placement.
              		 */
              		create(tag: NodeOrString, attrs?: GenericObject, refNode?: NodeOrString, pos?: string /* PosString */ | number): HTMLElement;
              		/**
              		 * safely removes all children of the node.
              		 */
              		empty(node: NodeOrString): void;
              		/**
              		 * Removes a node from its parent, clobbering it and all of its
              		 * children.
              		 */
              		destroy(node: NodeOrString): void;
              	}
              	/* dojo/dom-form */
              	interface DomForm {
              		/**
              		 * Serialize a form field to a JavaScript object.
              		 */
              		fieldToObject(inputNode: NodeOrString): GenericObject;
              		/**
              		 * Serialize a form node to a JavaScript object.
              		 */
              		toObject(fromNode: HTMLFormElement | string): GenericObject;
              		/**
              		 * Returns a URL-encoded string representing the form passed as either a
              		 * node or string ID identifying the form to serialize
              		 */
              		toQuery(fromNode: HTMLFormElement | string): string;
              		/**
              		 * Create a serialized JSON string from a form node or string
              		 * ID identifying the form to serialize
              		 */
              		toJson(formNode: HTMLFormElement | string, prettyPrint?: boolean): string;
              	}
              	/* dojo/dom-geometry */
              	interface DomGeometryWidthHeight {
              		w?: number;
              		h?: number;
              	}
              	interface DomGeometryBox extends DomGeometryWidthHeight {
              		l?: number;
              		t?: number;
              	}
              	interface DomGeometryBoxExtents extends DomGeometryBox {
              		r?: number;
              		b?: number;
              	}
              	interface Point {
              		x: number;
              		y: number;
              	}
              	interface DomGeometryXYBox extends DomGeometryWidthHeight, Point {
              	}
              	interface DomGeometry {
              		boxModel: string; /* TODO: string literal 'border-box' | 'content-box' */
              		/**
              		 * Returns object with special values specifically useful for node
              		 * fitting.
              		 */
              		getPadExtents(node: Element, computedStyle?: DomComputedStyle): DomGeometryBoxExtents;
              		/**
              		 * returns an object with properties useful for noting the border
              		 * dimensions.
              		 */
              		getBorderExtents(node: Element, computedStyle?: DomComputedStyle): DomGeometryBoxExtents;
              		/**
              		 * Returns object with properties useful for box fitting with
              		 * regards to padding.
              		 */
              		getPadBorderExtents(node: Element, computedStyle?: DomComputedStyle): DomGeometryBoxExtents;
              		/**
              		 * returns object with properties useful for box fitting with
              		 * regards to box margins (i.e., the outer-box).
              		 * - l/t = marginLeft, marginTop, respectively
              		 * - w = total width, margin inclusive
              		 * - h = total height, margin inclusive
              		 * The w/h are used for calculating boxes.
              		 * Normally application code will not need to invoke this
              		 * directly, and will use the ...box... functions instead.
              		 */
              		getMarginExtents(node: Element, computedStyle?: DomComputedStyle): DomGeometryBoxExtents;
              		/**
              		 * returns an object that encodes the width, height, left and top
              		 * positions of the node's margin box.
              		 */
              		getMarginBox(node: Element, computedStyle?: DomComputedStyle): DomGeometryBox;
              		/**
              		 * Returns an object that encodes the width, height, left and top
              		 * positions of the node's content box, irrespective of the
              		 * current box model.
              		 */
              		getContentBox(node: Element, computedStyle?: DomComputedStyle): DomGeometryBox;
              		/**
              		 * Sets the size of the node's contents, irrespective of margins,
              		 * padding, or borders.
              		 */
              		setContentSize(node: Element, box: DomGeometryWidthHeight, computedStyle?: DomComputedStyle): void;
              		/**
              		 * sets the size of the node's margin box and placement
              		 * (left/top), irrespective of box model. Think of it as a
              		 * passthrough to setBox that handles box-model vagaries for
              		 * you.
              		 */
              		setMarginBox(node: Element, box: DomGeometryBox, computedStyle?: DomComputedStyle): void;
              		/**
              		 * Returns true if the current language is left-to-right, and false otherwise.
              		 */
              		isBodyLtr(doc?: Document): boolean;
              		/**
              		 * Returns an object with {node, x, y} with corresponding offsets.
              		 */
              		docScroll(doc?: Document): Point;
              		/**
              		 * Deprecated method previously used for IE6-IE7.  Now, just returns `{x:0, y:0}`.
              		 */
              		getIeDocumentElementOffset(doc: Document): Point;
              		/**
              		 * In RTL direction, scrollLeft should be a negative value, but IE
              		 * returns a positive one. All codes using documentElement.scrollLeft
              		 * must call this function to fix this error, otherwise the position
              		 * will offset to right when there is a horizontal scrollbar.
              		 */
              		fixIeBiDiScrollLeft(scrollLeft: number, doc?: Document): number;
              		/**
              		 * Gets the position and size of the passed element relative to
              		 * the viewport (if includeScroll==false), or relative to the
              		 * document root (if includeScroll==true).
              		 */
              		position(node: Element, includeScroll?: boolean): DomGeometryXYBox;
              		/**
              		 * returns an object that encodes the width and height of
              		 * the node's margin box
              		 */
              		getMarginSize(node: Element, computedStyle?: DomComputedStyle): DomGeometryWidthHeight;
              		/**
              		 * Normalizes the geometry of a DOM event, normalizing the pageX, pageY,
              		 * offsetX, offsetY, layerX, and layerX properties
              		 */
              		normalizeEvent(event: Event): void;
              	}
              	/* dojo/dom-prop */
              	interface DomProp {
              		/**
              		 * Gets a property on an HTML element.
              		 */
              		get(node: ElementOrString, name: string): any;
              		/**
              		 * Sets a property on an HTML element.
              		 */
              		set(node: ElementOrString, name: string | GenericObject, value?: any): Element;
              	}
              	/* dojo/dom-style */
              	// TODO move over the most common properties from CSSStyleDeclaration
              	interface DomComputedStyle {
              		position?: string;
              		width?: string;
              		height?: string;
              		[id: string]: any;
              	}
              	interface DomStyle {
              		/**
              		 * Returns a "computed style" object.
              		 */
              		getComputedStyle(node: Node): DomComputedStyle;
              		/**
              		 * Accesses styles on a node.
              		 */
              		get(node: ElementOrString): DomComputedStyle;
              		get(node: ElementOrString, name: string): string | number;
              		/**
              		 * Sets styles on a node.
              		 */
              		set(node: ElementOrString, name: DomComputedStyle): DomComputedStyle;
              		set(node: ElementOrString, name: string, value: string | number): DomComputedStyle;
              		/**
              		 * converts style value to pixels on IE or return a numeric value.
              		 */
              		toPixelValue(element: Element, value: string): number;
              	}
              	/* dojo/domReady */
              	interface DomReady {
              		/**
              		 * Plugin to delay require()/define() callback from firing until the DOM has finished
              		 */
              		(callback: Function): void;
              		load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */
              		_Q: Function[];
              		_onEmpty(): void;
              	}
              	/* dojo/Evented */
              	interface Evented {
              		on(type: string | ExtensionEvent, listener: EventListener | Function): Handle;
              		emit(type: string | ExtensionEvent, ...events: any[]): boolean;
              	}
              	interface EventedConstructor extends _base.DeclareConstructor<Evented> {
              		new (params?: Object): Evented;
              	}
              	/* dojo/fx */
              	/* dojo/fx augments the dojo/_base/fx, therefore it is typed in fx.d.ts and not referenced from
              	  index.d.ts or module.d.ts and is self contained typings for dojo/fx and dojo/fx/* */
              	/* dojo/gears */
              	/* This is long-ago deprecated by Google, so just doing a minimal typing */
              	interface Gears {
              		_gearsObject(): any;
              		available: boolean;
              	}
              	/* dojo/has */
              	interface HasCache {
              		[feature: string]: any;
              	}
              	interface HasTestFunction {
              		/* TypeScript has no way of referring to the global scope see Microsoft/TypeScript#983 */
              		(global?: any, doc?: Document, element?: Element): any;
              	}
              	interface Has {
              		/**
              		 * Return the current value of the named feature.
              		 * @param {string | number} name The name (if a string) or identifier (if an integer) of the feature to test.
              		 */
              		(name: string | number): any;
              		(name: 'host-browser'): boolean;
              		(name: 'host-node'): any;
              		(name: 'host-rhino'): boolean;
              		(name: 'dom'): boolean;
              		(name: 'dojo-dom-ready-api'): 1;
              		(name: 'dojo-sniff'): 1;
              		// if host-browser is true
              		(name: 'dom-addeventlistener'): void | boolean;
              		(name: 'touch'): void | boolean;
              		(name: 'touch-events'): void | boolean;
              		(name: 'pointer-events'): void | boolean;
              		(name: 'MSPointer'): void | boolean;
              		(name: 'device-width'): void | number;
              		(name: 'dom-attributes-explicit'): void | boolean;
              		(name: 'dom-attributes-specified-flag'): void | boolean;
              		// dojo/_base/browser
              		(name: 'config-selectorEngine'): string;
              		cache: HasCache;
              		/**
              		 * Register a new feature test for some named feature.
              		 */
              		add(name: string | number, test: HasTestFunction, now?: boolean, force?: boolean): any;
              		add<T extends (Object | string | number | boolean | null | void)>(name: string | number, test: T, now?: boolean, force?: boolean): any;
              		/**
              		 * Deletes the contents of the element passed to test functions.
              		 */
              		clearElement(element: HTMLElement): HTMLElement;
              		/**
              		 * Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s).
              		 */
              		normalize(id: string, toAbsMid: Function): string; /* TODO: Align with loader api */
              		/**
              		 * Conditional loading of AMD modules based on a has feature test value.
              		 */
              		load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */
              	}
              	/* dojo/hash */
              	interface Hash {
              		(hash?: string, replace?: boolean): string;
              	}
              	/* dojo/hccss */
              	/* this only does has.add and re-exports the has interface */
              	interface Has {
              		(name: 'highcontrast'): void | boolean;
              	}
              	/* dojo/html */
              	type ContentSetterContent = string | Node | ArrayLike<Node>;
              	interface ContentSetterParams {
              		node?: NodeOrString;
              		content?: ContentSetterContent;
              		id?: string;
              		cleanContent?: boolean;
              		extractContent?: boolean;
              		parseContent?: boolean;
              		parserScope?: boolean;
              		startup?: boolean;
              		onBegin?: Function;
              		onEnd?: Function;
              		tearDown?: Function;
              		onContentError?: Function;
              		onExecError?: Function;
              	}
              	interface ContentSetter {
              		/**
              		 * An node which will be the parent element that we set content into
              		 */
              		node: NodeOrString;
              		/**
              		 * The content to be placed in the node. Can be an HTML string, a node reference, or a enumerable list of nodes
              		 */
              		content: ContentSetterContent;
              		/**
              		 * Usually only used internally, and auto-generated with each instance
              		 */
              		id: string;
              		/**
              		 * Should the content be treated as a full html document,
              		 * and the real content stripped of <html>, <body> wrapper before injection
              		 */
              		cleanContent: boolean;
              		/**
              		 * Should the content be treated as a full html document,
              		 * and the real content stripped of `<html> <body>` wrapper before injection
              		 */
              		extractContent: boolean;
              		/**
              		 * Should the node by passed to the parser after the new content is set
              		 */
              		parseContent: boolean;
              		/**
              		 * Flag passed to parser.	Root for attribute names to search for.	  If scopeName is dojo,
              		 * will search for data-dojo-type (or dojoType).  For backwards compatibility
              		 * reasons defaults to dojo._scopeName (which is "dojo" except when
              		 * multi-version support is used, when it will be something like dojo16, dojo20, etc.)
              		 */
              		parserScope: string;
              		/**
              		 * Start the child widgets after parsing them.	  Only obeyed if parseContent is true.
              		 */
              		startup: boolean;
              		/**
              		 * front-end to the set-content sequence
              		 */
              		set(cont?: ContentSetterContent, params?: ContentSetterParams): promise.Promise<Node> | Node;
              		/**
              		 * sets the content on the node
              		 */
              		setContent(): void;
              		/**
              		 * cleanly empty out existing content
              		 */
              		empty(): void;
              		/**
              		 * Called after instantiation, but before set();
              		 * It allows modification of any of the object properties -
              		 * including the node and content provided - before the set operation actually takes place
              		 */
              		onBegin(): Node;
              		/**
              		 * Called after set(), when the new content has been pushed into the node
              		 * It provides an opportunity for post-processing before handing back the node to the caller
              		 * This default implementation checks a parseContent flag to optionally run the dojo parser over the new content
              		 */
              		onEnd(): Node;
              		/**
              		 * manually reset the Setter instance if its being re-used for example for another set()
              		 */
              		tearDown(): void;
              		onContentError(): string;
              		onExecError(): string;
              		_mixin(params: ContentSetterParams): void;
              		parseDeferred: Deferred<any[]>;
              		/**
              		 * runs the dojo parser over the node contents, storing any results in this.parseResults
              		 */
              		_parse(): void;
              		/**
              		 * shows user the string that is returned by on[type]Error
              		 * override/implement on[type]Error and return your own string to customize
              		 */
              		_onError(type: string, err: Error, consoleText?: string): void;
              	}
              	interface ContentSetterConstructor extends _base.DeclareConstructor<ContentSetter> {
              		new (params?: ContentSetterParams, node?: NodeOrString): ContentSetter;
              	}
              	interface Html {
              		/**
              		 * removes !DOCTYPE and title elements from the html string.
              		 *
              		 * khtml is picky about dom faults, you can't attach a style or `<title>` node as child of body
              		 * must go into head, so we need to cut out those tags
              		 */
              		_secureForInnerHtml(cont: string): string;
              		/**
              		 * Deprecated, should use dojo/dom-constuct.empty() directly, remove in 2.0.
              		 */
              		_emptyNode(node: NodeOrString): void;
              		/**
              		 * inserts the given content into the given node
              		 */
              		_setNodeContent<T extends Node>(node: Node, cont: string | Node | ArrayLike<T>): Node;
              		_ContentSetter: ContentSetterConstructor;
              		/**
              		 * inserts (replaces) the given content into the given node. dojo/dom-construct.place(cont, node, "only")
              		 * may be a better choice for simple HTML insertion.
              		 */
              		set(node: Node, cont?: ContentSetterContent, params?: ContentSetterParams): promise.Promise<Node> | Node;
              	}
              	/* dojo/i18n */
              	interface I18n {
              		getLocalization(moduleName: string, bundleName: string, locale?: string): any;
              		dynamic: boolean;
              		/**
              		 * Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s).
              		 */
              		normalize(id: string, toAbsMid: Function): string; /* TODO: Align with loader api */
              		normalizeLocale(locale?: string): string;
              		/**
              		 * Conditional loading of AMD modules based on a has feature test value.
              		 */
              		load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */
              		cache: { [bundle: string]: any };
              		getL10nName(moduleName: string, bundleName: string, locale?: string): string;
              	}
              	/* dojo/io-query */
              	interface IoQuery {
              		/**
              		 * takes a name/value mapping object and returns a string representing
              		 * a URL-encoded version of that object.
              		 */
              		objectToQuery(map: GenericObject): string;
              		/**
              		 * Create an object representing a de-serialized query section of a
              		 * URL. Query keys with multiple values are returned in an array.
              		 */
              		queryToObject(str: string): GenericObject;
              	}
              	/* dojo/json */
              	interface Json {
              		/**
              		 * Parses a [JSON](http://json.org) string to return a JavaScript object.
              		 */
              		parse(str: string, strict?: boolean): any;
              		/**
              		 * Returns a [JSON](http://json.org) serialization of an object.
              		 */
              		stringify(value: any, replacer?: (key: string, value: any) => any| any[], space?: string | number): string;
              	}
              	/* dojo/keys */
              	interface Keys {
              		BACKSPACE: number;
              		TAB: number;
              		CLEAR: number;
              		ENTER: number;
              		SHIFT: number;
              		CTRL: number;
              		ALT: number;
              		META: number;
              		PAUSE: number;
              		CAPS_LOCK: number;
              		ESCAPE: number;
              		SPACE: number;
              		PAGE_UP: number;
              		PAGE_DOWN: number;
              		END: number;
              		HOME: number;
              		LEFT_ARROW: number;
              		UP_ARROW: number;
              		RIGHT_ARROW: number;
              		DOWN_ARROW: number;
              		INSERT: number;
              		DELETE: number;
              		HELP: number;
              		LEFT_WINDOW: number;
              		RIGHT_WINDOW: number;
              		SELECT: number;
              		NUMPAD_0: number;
              		NUMPAD_1: number;
              		NUMPAD_2: number;
              		NUMPAD_3: number;
              		NUMPAD_4: number;
              		NUMPAD_5: number;
              		NUMPAD_6: number;
              		NUMPAD_7: number;
              		NUMPAD_8: number;
              		NUMPAD_9: number;
              		NUMPAD_MULTIPLY: number;
              		NUMPAD_PLUS: number;
              		NUMPAD_ENTER: number;
              		NUMPAD_MINUS: number;
              		NUMPAD_PERIOD: number;
              		NUMPAD_DIVIDE: number;
              		F1: number;
              		F2: number;
              		F3: number;
              		F4: number;
              		F5: number;
              		F6: number;
              		F7: number;
              		F8: number;
              		F9: number;
              		F10: number;
              		F11: number;
              		F12: number;
              		F13: number;
              		F14: number;
              		F15: number;
              		NUM_LOCK: number;
              		SCROLL_LOCK: number;
              		UP_DPAD: number;
              		DOWN_DPAD: number;
              		LEFT_DPAD: number;
              		RIGHT_DPAD: number;
              		copyKey: number;
              	}
              	/* dojo/loadInit */
              	interface LoadInit {
              		dynamic: number;
              		/**
              		 * Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s).
              		 */
              		normalize(id: string, toAbsMid: Function): string; /* TODO: Align with loader api */
              		/**
              		 * Conditional loading of AMD modules based on a has feature test value.
              		 */
              		load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */
              	}
              	/* dojo/mouse */
              	interface Mouse {
              		_eventHandler(type: string, selectHandler?: (evt: MouseEvent, listener: EventListener) => void): MouseEvent;
              		/**
              		 * This is an extension event for the mouseenter that IE provides, emulating the
              		 * behavior on other browsers.
              		 */
              		enter: MouseEvent;
              		/**
              		 * This is an extension event for the mouseleave that IE provides, emulating the
              		 * behavior on other browsers.
              		 */
              		leave: MouseEvent;
              		/**
              		 * This is an extension event for the mousewheel that non-Mozilla browsers provide,
              		 * emulating the behavior on Mozilla based browsers.
              		 */
              		wheel: string | ExtensionEvent;
              		/**
              		 * Test an event object (from a mousedown event) to see if the left button was pressed.
              		 */
              		isLeft(e: MouseEvent): boolean;
              		/**
              		 * Test an event object (from a mousedown event) to see if the middle button was pressed.
              		 */
              		isMiddle(e: MouseEvent): boolean;
              		/**
              		 * Test an event object (from a mousedown event) to see if the right button was pressed.
              		 */
              		isRight(e: MouseEvent): boolean;
              	}
              	/* dojo/node */
              	/* should only be used for re-exporting CommonJS modules */
              	/* dojo/NodeList */
              	/* Just proxies dojo/query::NodeList */
              	/* dojo/NodeList-* are included as seperate .d.ts files */
              	/* dojo/number */
              	interface NumberFormatOptions {
              		/**
              		 * override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
              		 * with this string.  Default value is based on locale.  Overriding this property will defeat
              		 * localization.  Literal characters in patterns are not supported.
              		 */
              		pattern?: string;
              		/**
              		 * choose a format type based on the locale from the following:
              		 * decimal, scientific (not yet supported), percent, currency. decimal by default.
              		 */
              		type?: string;
              		/**
              		 * fixed number of decimal places to show.  This overrides any
              		 * information in the provided pattern.
              		 */
              		places?: number;
              		/**
              		 * 5 rounds to nearest .5; 0 rounds to nearest whole (default). -1
              		 * means do not round.
              		 */
              		round?: number;
              		/**
              		 * override the locale used to determine formatting rules
              		 */
              		locale?: string;
              		/**
              		 * If false, show no decimal places, overriding places and pattern settings.
              		 */
              		fractional?: boolean | [ boolean, boolean ];
              	}
              	interface NumberFormatAbsoluteOptions {
              		/**
              		 * the decimal separator
              		 */
              		decimal?: string;
              		/**
              		 * the group separator
              		 */
              		group?: string;
              		/**
              		 * number of decimal places.  the range "n,m" will format to m places.
              		 */
              		places?: number | string;
              		/**
              		 * 5 rounds to nearest .5; 0 rounds to nearest whole (default). -1
              		 * means don't round.
              		 */
              		round?: number;
              	}
              	interface NumberRegexpOptions {
              		/**
              		 * override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
              		 * with this string.  Default value is based on locale.  Overriding this property will defeat
              		 * localization.
              		 */
              		pattern?: string;
              		/**
              		 * choose a format type based on the locale from the following:
              		 * decimal, scientific (not yet supported), percent, currency. decimal by default.
              		 */
              		type?: string;
              		/**
              		 * override the locale used to determine formatting rules
              		 */
              		locacle?: string;
              		/**
              		 * strict parsing, false by default.  Strict parsing requires input as produced by the format() method.
              		 * Non-strict is more permissive, e.g. flexible on white space, omitting thousands separators
              		 */
              		strict?: boolean;
              		/**
              		 * number of decimal places to accept: Infinity, a positive number, or
              		 * a range "n,m".  Defined by pattern or Infinity if pattern not provided.
              		 */
              		places?: number | string;
              	}
              	interface NumberParseOptions {
              		/**
              		 * override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
              		 * with this string.  Default value is based on locale.  Overriding this property will defeat
              		 * localization.  Literal characters in patterns are not supported.
              		 */
              		pattern?: string;
              		/**
              		 * choose a format type based on the locale from the following:
              		 * decimal, scientific (not yet supported), percent, currency. decimal by default.
              		 */
              		type?: string;
              		/**
              		 * override the locale used to determine formatting rules
              		 */
              		locale?: string;
              		/**
              		 * strict parsing, false by default.  Strict parsing requires input as produced by the format() method.
              		 * Non-strict is more permissive, e.g. flexible on white space, omitting thousands separators
              		 */
              		strict?: boolean;
              		/**
              		 * Whether to include the fractional portion, where the number of decimal places are implied by pattern
              		 * or explicit 'places' parameter.  The value [true,false] makes the fractional portion optional.
              		 */
              		fractional?: boolean | [boolean, boolean];
              	}
              	interface RealNumberRegexpFlags {
              		/**
              		 * The integer number of decimal places or a range given as "n,m".  If
              		 * not given, the decimal part is optional and the number of places is
              		 * unlimited.
              		 */
              		places?: number;
              		/**
              		 * A string for the character used as the decimal point.  Default
              		 * is ".".
              		 */
              		decimal?: string;
              		/**
              		 * Whether decimal places are used.  Can be true, false, or [true,
              		 * false].  Default is [true, false] which means optional.
              		 */
              		fractional?: boolean | [boolean, boolean];
              		/**
              		 * Express in exponential notation.  Can be true, false, or [true,
              		 * false]. Default is [true, false], (i.e. will match if the
              		 * exponential part is present are not).
              		 */
              		exponent?: boolean | [boolean, boolean];
              		/**
              		 * The leading plus-or-minus sign on the exponent.  Can be true,
              		 * false, or [true, false].  Default is [true, false], (i.e. will
              		 * match if it is signed or unsigned).  flags in regexp.integer can be
              		 * applied.
              		 */
              		eSigned?: boolean | [boolean, boolean];
              	}
              	interface IntegerRegexpFlags {
              		/**
              		 * The leading plus-or-minus sign. Can be true, false, or `[true,false]`.
              		 * Default is `[true, false]`, (i.e. will match if it is signed
              		 * or unsigned).
              		 */
              		signed?: boolean;
              		/**
              		 * The character used as the thousands separator. Default is no
              		 * separator. For more than one symbol use an array, e.g. `[",", ""]`,
              		 * makes ',' optional.
              		 */
              		separator?: string;
              		/**
              		 * group size between separators
              		 */
              		groupSize?: number;
              		/**
              		 * second grouping, where separators 2..n have a different interval than the first separator (for India)
              		 */
              		groupSize2?: number;
              	}
              	interface Number {
              		/**
              		 * Format a Number as a String, using locale-specific settings
              		 */
              		format(value: number, options?: NumberFormatOptions): string;
              		/**
              		 * not precise, but good enough
              		 */
              		_numberPatternRE: RegExp;
              		/**
              		 * Apply pattern to format value as a string using options. Gives no
              		 * consideration to local customs.
              		 */
              		_applyPattern(value: number, pattern: string, options?: NumberFormatOptions): string;
              		/**
              		 * Rounds to the nearest value with the given number of decimal places, away from zero
              		 */
              		round(value: number, places?: number, increment?: number): number;
              		/**
              		 * Apply numeric pattern to absolute value using options. Gives no
              		 * consideration to local customs.
              		 */
              		_formatAbsolute(value: number, pattern: string, options?: NumberFormatAbsoluteOptions): string;
              		/**
              		 * Builds the regular needed to parse a number
              		 */
              		regexp(options?: NumberRegexpOptions): string;
              		_parseInfo(options?: any): { regexp: string, group: string, decimal: string, factor: number };
              		/**
              		 * Convert a properly formatted string to a primitive Number, using
              		 * locale-specific settings.
              		 */
              		parse(expression: string, options?: NumberParseOptions): number;
              		/**
              		 * Builds a regular expression to match a real number in exponential
              		 * notation
              		 */
              		_realNumberRegexp(flags: RealNumberRegexpFlags): string;
              		/**
              		 * Builds a regular expression that matches an integer
              		 */
              		_integerRegexp(flags: IntegerRegexpFlags): string;
              	}
              	/* dojo/on */
              	interface ExtensionEvent {
              		(target: Element | GenericObject, listener: EventListener): Handle;
              	}
              	interface PauseHandle extends Handle {
              		pause(): void;
              		resume(): void;
              	}
              	interface MatchesTarget {
              		matches(node: Element, selector: string, context?: any): any[];
              		[id: string]: any;
              	}
              	interface On {
              		/**
              		 * A function that provides core event listening functionality. With this function
              		 * you can provide a target, event type, and listener to be notified of
              		 * future matching events that are fired.
              		 */
              		(target: Element | GenericObject, type: string | ExtensionEvent, listener: EventListener | Function, dontFix?: boolean): Handle;
              		/**
              		 * This function acts the same as on(), but with pausable functionality. The
              		 * returned signal object has pause() and resume() functions. Calling the
              		 * pause() method will cause the listener to not be called for future events.
              		 */
              		pausable(target: Element | GenericObject, type: string | ExtensionEvent, listener: EventListener | Function, dontFix?: boolean): PauseHandle;
              		/**
              		 * This function acts the same as on(), but will only call the listener once. The
              		 * listener will be called for the first
              		 * event that takes place and then listener will automatically be removed.
              		 */
              		once(target: Element | GenericObject, type: string | ExtensionEvent, listener: EventListener | Function, dontFix?: boolean): Handle;
              		parse(target: Element | GenericObject, type: string | ExtensionEvent, listener: EventListener | Function, dontFix: boolean, matchesTarget: Element | GenericObject): Handle;
              		/**
              		 * Check if a node match the current selector within the constraint of a context
              		 */
              		matches(node: Element, selector: string, context: Element, children: boolean, matchesTarget?: MatchesTarget): Element | boolean;
              		/**
              		 * Creates a new extension event with event delegation. This is based on
              		 * the provided event type (can be extension event) that
              		 * only calls the listener when the CSS selector matches the target of the event.
              		 *
              		 * The application must require() an appropriate level of dojo/query to handle the selector.
              		 */
              		selector(selector: string, type: string | ExtensionEvent, children?: boolean): ExtensionEvent;
              		/**
              		 * Fires an event on the target object.
              		 */
              		emit(target: Element | GenericObject, type: string | ExtensionEvent, event?: any): boolean;
              		/**
              		 * normalizes properties on the event object including event
              		 * bubbling methods, keystroke normalization, and x/y positions
              		 */
              		_fixEvent(evt: any, sender: any): any;
              	}
              	/* dojo/parser */
              	interface ParserOptions { }
              	interface ParserObjects {
              		ctor?: GenericConstructor<any>;
              		types?: string[];
              		node: Node;
              		scripts?: HTMLScriptElement[];
              		inherited?: { [prop: string]: any; };
              	}
              	interface InstancesArray extends Array<any>, promise.Promise<any> {}
              	interface Parser {
              		/**
              		 * Clear cached data.   Used mainly for benchmarking.
              		 */
              		_clearCache(): void;
              		/**
              		 * Convert a `<script type="dojo/method" args="a, b, c"> ... </script>`
              		 * into a function
              		 */
              		_functionFromScript(node: HTMLScriptElement, attrData: string): Function;
              		/**
              		 * Takes array of nodes, and turns them into class instances and
              		 * potentially calls a startup method to allow them to connect with
              		 * any children.
              		 */
              		instantiate(nodes: Node[], mixin?: Object, options?: ParserOptions): any[];
              		/**
              		 * Takes array of objects representing nodes, and turns them into class instances and
              		 * potentially calls a startup method to allow them to connect with
              		 * any children.
              		 */
              		_instantiate(nodes: ParserObjects[], mixin?: Object, options?: ParserOptions, returnPromise?: boolean): any[] | promise.Promise<any[]>;
              		/**
              		 * Calls new ctor(params, node), where params is the hash of parameters specified on the node,
              		 * excluding data-dojo-type and data-dojo-mixins.   Does not call startup().
              		 */
              		construct<T>(
              			ctor: GenericConstructor<T>,
              			node: Node, mixin?: Object,
              			options?: ParserOptions,
              			scripts?: HTMLScriptElement[],
              			inherited?: { [prop: string]: any; }
              		): promise.Promise<T> | T;
              		/**
              		 * Scan a DOM tree and return an array of objects representing the DOMNodes
              		 * that need to be turned into widgets.
              		 */
              		scan(root?: Node, options?: ParserOptions): promise.Promise<ParserObjects[]>;
              		/**
              		 * Helper for _scanAMD().  Takes a `<script type=dojo/require>bar: "acme/bar", ...</script>` node,
              		 * calls require() to load the specified modules and (asynchronously) assign them to the specified global
              		 * variables, and returns a Promise for when that operation completes.
              		 *
              		 * In the example above, it is effectively doing a require(["acme/bar", ...], function(a){ bar = a; }).
              		 */
              		_require(script: HTMLScriptElement, options: ParserOptions): promise.Promise<any>;
              		/**
              		 * Scans the DOM for any declarative requires and returns their values.
              		 */
              		_scanAmd(root?: Node, options?: ParserOptions): promise.Promise<boolean>;
              		/**
              		 * Scan the DOM for class instances, and instantiate them.
              		 */
              		parse(rootNode?: Node, options?: ParserOptions): InstancesArray;
              	}
              	/* dojo/query */
              	interface NodeListFilterCallback<T extends Node> {
              		(item: T, idx: number, nodeList: this): boolean;
              	}
              	type NodeListFilter<T extends Node> = string | NodeListFilterCallback<T>;
              	interface NodeList<T extends Node> extends ArrayLike<T> {
              		/**
              		 * decorate an array to make it look like a `dojo/NodeList`.
              		 */
              		_wrap<U extends Node, V extends Node>(a: U[], parent?: NodeList<V>, NodeListCtor?: NodeListConstructor): NodeList<U>;
              		_NodeListCtor: NodeListConstructor;
              		toString(): string;
              		/**
              		 * private function to hold to a parent NodeList. end() to return the parent NodeList.
              		 */
              		_stash(parent: Node): this;
              		/**
              		 * Listen for events on the nodes in the NodeList.
              		 */
              		on(eventName: string, listener: EventListener): Handle[];
              		/**
              		 * Ends use of the current `NodeList` by returning the previous NodeList
              		 * that generated the current NodeList.
              		 */
              		end<U extends Node>(): NodeList<U>;
              		/**
              		 * Returns a new NodeList, maintaining this one in place
              		 */
              		slice(begin: number, end?: number): this;
              		/**
              		 * Returns a new NodeList, manipulating this NodeList based on
              		 * the arguments passed, potentially splicing in new elements
              		 * at an offset, optionally deleting elements
              		 */
              		splice(index: number, howmany?: number, ...items: T[]): this;
              		/**
              		 * see `dojo/_base/array.indexOf()`. The primary difference is that the acted-on
              		 * array is implicitly this NodeList
              		 */
              		indexOf(value: T, fromIndex?: number, findLast?: boolean): number;
              		/**
              		 * see `dojo/_base/array.lastIndexOf()`. The primary difference is that the
              		 * acted-on array is implicitly this NodeList
              		 */
              		lastIndexOf(value: T, fromIndex?: number): number;
              		/**
              		 * see `dojo/_base/array.every()` and the [Array.every
              		 * docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every).
              		 * Takes the same structure of arguments and returns as
              		 * dojo/_base/array.every() with the caveat that the passed array is
              		 * implicitly this NodeList
              		 */
              		every(callback: (item: T, idx: number, nodeList: this) => boolean | string, thisObj?: Object): boolean;
              		/**
              		 * Takes the same structure of arguments and returns as
              		 * `dojo/_base/array.some()` with the caveat that the passed array as
              		 * implicitly this NodeList.  See `dojo/_base/array.some()` and Mozillaas
              		 * [Array.soas
              		 * documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some).
              		 */
              		some(callback: (item: T, idx: number, nodeList: this) => boolean | string, thisObj?: Object): boolean;
              		/**
              		 * Returns a new NodeList comprised of items in this NodeList
              		 * as well as items passed in as parameters
              		 */
              		concat(...items: T[]): this;
              		/**
              		 * see `dojo/_base/array.map()`. The primary difference is that the acted-on
              		 * array is implicitly this NodeList and the return is a
              		 * NodeList (a subclass of Array)
              		 */
              		map<U extends Node>(func: (item: T, idx: number, nodeList: this) => U, obj?: Object): NodeList<U>;
              		/**
              		 * see `dojo/_base/array.forEach()`. The primary difference is that the acted-on
              		 * array is implicitly this NodeList. If you want the option to break out
              		 * of the forEach loop, use every() or some() instead.
              		 */
              		forEach(callback: (item: T, idx: number, nodeList: this) => void, thisObj?: Object): this;
              		/**
              		 * "masks" the built-in javascript filter() method (supported
              		 * in Dojo via `dojo/_base/array.filter`) to support passing a simple
              		 * string filter in addition to supporting filtering function
              		 * objects.
              		 */
              		filter<U extends Node>(filter: NodeListFilter<T>, thisObj?: Object): NodeList<U>;
              		/**
              		 * Create a new instance of a specified class, using the
              		 * specified properties and each node in the NodeList as a
              		 * srcNodeRef.
              		 */
              		instantiate(declaredClass: string | GenericConstructor<any>, properties?: Object): this;
              		/**
              		 * Returns a new NodeList comprised of items in this NodeList
              		 * at the given index or indices.
              		 */
              		at(...indices: number[]): this;
              	}
              	interface NodeListConstructor {
              		new <T extends Node>(array: number | Array<T>): NodeList<T>;
              		new <T extends Node>(...args: T[]): NodeList<T>;
              		<T extends Node>(array: number | Array<T>): NodeList<T>;
              		<T extends Node>(...args: T[]): NodeList<T>;
              		prototype: NodeList<any>;
              		/**
              		 * decorate an array to make it look like a `dojo/NodeList`.
              		 */
              		_wrap<U extends Node, V extends Node>(a: U[], parent?: NodeList<V>, NodeListCtor?: NodeListConstructor): NodeList<U>;
              		/**
              		 * adapts a single node function to be used in the map-type
              		 * actions. The return is a new array of values, as via `dojo/_base/array.map`
              		 */
              		_adaptAsMap<T extends Node, U extends Node>(f: (node: T) => U, o?: Object): NodeList<U>;
              		/**
              		 * adapts a single node function to be used in the forEach-type
              		 * actions. The initial object is returned from the specialized
              		 * function.
              		 */
              		_adaptAsForEach<T extends Node>(f: (node: T) => void, o?: Object): this;
              		/**
              		 * adapts a single node function to be used in the filter-type actions
              		 */
              		_adaptAsFilter<T extends Node>(f: (node: T) => boolean, o?: Object): this;
              		/**
              		 * adapts a single node function to be used in the map-type
              		 * actions, behaves like forEach() or map() depending on arguments
              		 */
              		_adaptWithCondition<T extends Node, U extends Node>(f: (node: T) => U | void, g: (...args: any[]) => boolean, o?: Object): NodeList<U> | this;
              	}
              	interface Query {
              		/**
              		 * Returns nodes which match the given CSS selector, searching the
              		 * entire document by default but optionally taking a node to scope
              		 * the search by. Returns an instance of NodeList.
              		 */
              		<T extends Node>(query: string, root?: NodeOrString): NodeList<T>;
              		/**
              		 * Test to see if a node matches a selector
              		 */
              		matches(node: Node, selector: string, root?: NodeOrString): boolean;
              		/**
              		 * Filters an array of nodes. Note that this does not guarantee to return a NodeList, just an array.
              		 */
              		filter<T extends Node>(nodes: NodeList<T> | T[], select: string, root?: NodeOrString): T[] | NodeList<T>;
              		/**
              		 * can be used as AMD plugin to conditionally load new query engine
              		 */
              		load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */
              	}
              	/* dojo/ready */
              	interface Ready {
              		/**
              		 * Add a function to execute on DOM content loaded and all requested modules have arrived and been evaluated.
              		 * In most cases, the `domReady` plug-in should suffice and this method should not be needed.
              		 *
              		 * When called in a non-browser environment, just checks that all requested modules have arrived and been
              		 * evaluated.
              		 */
              		(callback: Function): void;
              		(context: Object, callback: Function | string): void;
              		(priority: number, callback: Function): void;
              		(priority: number, context: Object, callback: Function | string): void;
              	}
              	/* dojo/regexp */
              	interface RegExpModule {
              		/**
              		 * Adds escape sequences for special characters in regular expressions
              		 */
              		escapeString(str: string, except?: string): string;
              		/**
              		 * Builds a regular expression that groups subexpressions
              		 */
              		buildGroupRE(arr: any[] | Object, re: (item: any) => string, nonCapture?: boolean): string;
              		/**
              		 * adds group match to expression
              		 */
              		group(expression: string, nonCapture?: boolean): string;
              	}
              	/* dojo/request */
              	/* This is contained in request.d.ts */
              	/* dojo/require */
              	interface RequirePlugin {
              		dynamic: number;
              		normalize(id: string): string;
              		load(mid: string, require: any, loaded: (...modules: any[]) => void): void;
              	}
              	/* dojo/robot */
              	interface Robot extends doh.Robot {
              		_resolveNode(n: NodeOrString | (() => Node)): Node;
              		_scrollIntoView(n: Node): void;
              		_position(n: Node): DomGeometryBoxExtents;
              		_getWindowChain(n: Node): Window[];
              		/**
              		 * Scroll the passed node into view, if it is not.
              		 */
              		scrollIntoView(node: NodeOrString | (() => Node), delay?: number): void;
              		/**
              		 * Moves the mouse over the specified node at the specified relative x,y offset.
              		 */
              		mouseMoveAt(
              			node: NodeOrString | (() => Node),
              			delay?: number,
              			duration?: number,
              			offsetX?: number,
              			offsetY?: number
              		): void;
              	}
              	/* dojo/robotx */
              	interface RobotX extends Robot {
              		/**
              		 * Called every time a new page is loaded into the iframe, to setup variables
              		 * Point dojo.global, dojo.publish, etc. to refer to iframe.
              		 * Remove for 2.0?
              		 */
              		_updateDocument(): void;
              		/**
              		 * Opens the application at the specified URL for testing, redirecting dojo to point to the application
              		 * environment instead of the test environment.
              		 */
              		initRobot(url: string): void;
              		/**
              		 * Notifies DOH that the doh.robot is about to make a page change in the application it is driving,
              		 * returning a doh.Deferred object the user should return in their runTest function as part of a DOH test.
              		 */
              		waitForPageToLoad(submitActions: () => void): any;
              	}
              	/* dojo/router */
              	/* Module just exports instance of dojo.router.BaseRouter */
              	/* dojo/sniff */
              	interface Has {
              		(name: 'air'): boolean;
              		(name: 'wp'): void | number;
              		(name: 'msapp'): void | number;
              		(name: 'khtml'): void | number;
              		(name: 'edge'): void | number;
              		(name: 'opr'): void | number;
              		(name: 'webkit'): void | number;
              		(name: 'chrome'): void | number;
              		(name: 'android'): void | number;
              		(name: 'safari'): void | number;
              		(name: 'mac'): boolean;
              		(name: 'quirks'): boolean;
              		(name: 'iphone'): void | number;
              		(name: 'ipod'): void | number;
              		(name: 'ipad'): void | number;
              		(name: 'ios'): void | number;
              		(name: 'bb'): void | number | boolean;
              		(name: 'trident'): void | number;
              		(name: 'svg'): boolean;
              		(name: 'opera'): void | number;
              		(name: 'mozilla'): void | number;
              		(name: 'ff'): void | number;
              		(name: 'ie'): void | number;
              		(name: 'wii'): boolean | any;
              	}
              	/* Just rexports has after adding features */
              	/* dojo/Stateful */
              	interface WatchHandle extends Handle {
              		unwatch(): void;
              	}
              	interface Stateful<T = any> {
              		/**
              		 * Used across all instances a hash to cache attribute names and their getter
              		 * and setter names.
              		 */
              		_attrPairNames: { [attr: string]: string };
              		/**
              		 * Helper function for get() and set().
              		 * Caches attribute name values so we don't do the string ops every time.
              		 */
              		_getAttrNames(name: string): string;
              		/**
              		 * Automatic setting of params during construction
              		 */
              		postscript(params?: Object): void;
              		/**
              		 * Get a property on a Stateful instance.
              		 */
              		get<K extends keyof T & string>(name: K): T[K];
              		/**
              		 * Set a property on a Stateful instance
              		 */
              		set<K extends keyof T & string>(name: K, value: T[K]): this;
              		set<K extends { [p in keyof T]: T[p] extends any[] ? p : never; }[keyof T & string] >(name: K, ...values: T[K]): this;
              		set(values: Partial<T>): this;
              		/**
              		 * Internal helper for directly changing an attribute value.
              		 */
              		_changeAttrValue(name: string, value: any): this;
              		/**
              		 * Watches a property for changes
              		 */
-             		watch(callback: <K extends keyof T>(prop: K, oldValue: T[K], newValue: T[K]) => void): WatchHandle;
+             		watch(callback:(prop: keyof any, oldValue: any, newValue: any) => void): WatchHandle;
              		watch<K extends keyof T>(name: K, callback: (prop: K, oldValue: T[K], newValue: T[K]) => void): WatchHandle;
              	}
              	interface StatefulConstructor extends _base.DeclareConstructor<Stateful> {
              		new <T>(params?: Partial<T>): Stateful<T>;
              	}
              	/* dojo/string */
              	interface String {
              		/**
              		 * Efficiently escape a string for insertion into HTML (innerHTML or attributes), replacing &, <, >, ", ', and / characters.
              		 */
              		escape(str: string): string;
              		/**
              		 * Efficiently replicate a string `n` times.
              		 */
              		rep(str: string, num: number): string;
              		/**
              		 * Pad a string to guarantee that it is at least `size` length by
              		 * filling with the character `ch` at either the start or end of the
              		 * string. Pads at the start, by default.
              		 */
              		pad(text: string, size: number, ch?: string, end?: boolean): string;
              		/**
              		 * Performs parameterized substitutions on a string. Throws an
              		 * exception if any parameter is unmatched.
              		 */
              		substitute(template: string, map: Object | any[], transform?: (value: any, key: string) => any, thisObject?: Object): string;
              		/**
              		 * Trims whitespace from both sides of the string
              		 */
              		trim(str: string): string;
              	}
              	/* dojo/text */
              	/**
              	 * A getter and setter for storing the string content associated with the
              	 * module and url arguments.
              	 */
              	interface Cache {
              		(module: string | GenericObject, url: string, value?: string | { value: string, sanitize?: boolean }): string;
              	}
              	interface Text {
              		/**
              		 * the dojo/text caches it's own resources because of dojo.cache
              		 */
              		dynamic: boolean;
              		normalize(id: string, toAbsMid: Function): string; /* TODO: Align with loader api */
              		load(id: string, parentRequire: Function, loaded: Function): void; /* TODO: Align with loader api */
              	}
              	/* dojo/throttle */
              	interface Throttle {
              		<T extends Function>(cb: T, wait: number): T;
              	}
              	/* dojo/topic */
              	interface Topic {
              		/**
              		 * Publishes a message to a topic on the pub/sub hub. All arguments after
              		 * the first will be passed to the subscribers, so any number of arguments
              		 * can be provided (not just event).
              		 */
              		publish(topic: string | ExtensionEvent, ...event: any[]): boolean;
              		/**
              		 * Subscribes to a topic on the pub/sub hub
              		 */
              		subscribe(topic: string | ExtensionEvent, listener: EventListener | Function): Handle;
              	}
              	/* dojo/touch */
              	interface Touch {
              		press: ExtensionEvent;
              		move: ExtensionEvent;
              		release: ExtensionEvent;
              		cancel: ExtensionEvent;
              		over: ExtensionEvent;
              		out: ExtensionEvent;
              		enter: ExtensionEvent;
              		leave: ExtensionEvent;
              	}
              	/* dojo/uacss */
              	/* rexports has after adding classes to dom */
              	/* dojo/when */
              	interface When {
              		/**
              		 * Transparently applies callbacks to values and/or promises.
              		 */
              		<T>(value: T | dojo.promise.Promise<T>): dojo.promise.Promise<T>;
              		<T>(value: T | dojo.promise.Promise<T>,
              			callback?: dojo.promise.PromiseCallback<T, T>,
              			errback?: dojo.promise.PromiseErrback<T>,
              			progress?: dojo.promise.PromiseProgback): T | dojo.promise.Promise<T>;
              		<T, U>(value: T | dojo.promise.Promise<T>,
              			callback?: dojo.promise.PromiseCallback<T, U>,
              			errback?: dojo.promise.PromiseErrback<U>,
              			progress?: dojo.promise.PromiseProgback): U | dojo.promise.Promise<U>;
              	}
              	/* dojo/window */
              	interface WindowModule {
              		/**
              		 * Returns the dimensions and scroll position of the viewable area of a browser window
              		 */
              		getBox(doc?: Document): DomGeometryBox;
              		/**
              		 * Get window object associated with document doc.
              		 */
              		get(doc?: Document): Window;
              		/**
              		 * Scroll the passed node into view using minimal movement, if it is not already.
              		 */
              		scrollIntoView(node: Element, pos?: DomGeometryXYBox): void;
              	}
              }

dojo-typings/src/main/typings/dojo/modules.d.ts +1 -1

              /// <reference path="index.d.ts" />
              declare module 'dojo/_base/array' {
              	const dojoArray: dojo._base.Array;
              	export = dojoArray;
              }
              declare module 'dojo/_base/browser' {
              	const ready: dojo.Ready;
              	export = ready;
              }
              declare module 'dojo/_base/Color' {
              	type Color = dojo._base.Color;
              	const Color: dojo._base.ColorConstructor;
              	export = Color;
              }
              declare module 'dojo/_base/config' {
              	const config: dojo._base.Config;
              	export = config;
              }
              declare module 'dojo/_base/connect' {
              	const connect: dojo._base.Connect;
              	export = connect;
              }
              declare module 'dojo/_base/declare' {
              	const dojoDeclare: dojo._base.Declare;
              	export = dojoDeclare;
              }
              declare module 'dojo/_base/Deferred' {
              	type Deferred<T> = dojo._base.Deferred<T>;
              	const Deferred: dojo._base.DeferredConstructor;
              	export = Deferred;
              }
              declare module 'dojo/_base/event' {
              	const event: dojo._base.EventModule;
              	export = event;
              }
              declare module 'dojo/_base/fx' {
              	const fx: dojo._base.Fx;
              	export = fx;
              }
              declare module 'dojo/_base/html' {
              	const dojo: dojo._base.Dojo;
              	export = dojo;
              }
              declare module 'dojo/_base/json' {
              	const dojo: dojo._base.Dojo;
              	export = dojo;
              }
              declare module 'dojo/_base/kernel' {
              	const dojo: dojo._base.Dojo;
              	export = dojo;
              }
              declare module 'dojo/_base/lang' {
              	const lang: dojo._base.Lang;
              	export = lang;
              }
              declare module 'dojo/_base/loader' {
              	const loader: dojo._base.Loader;
              	export = loader;
              }
              declare module 'dojo/_base/NodeList' {
              	type NodeList<T extends Node> = dojo.NodeList<T>;
              	const NodeList: dojo.NodeListConstructor;
              	export = NodeList;
              }
              declare module 'dojo/_base/query' {
              	const query: dojo.Query;
              	export = query;
              }
              declare module 'dojo/_base/sniff' {
              	const has: dojo.Has;
              	export = has;
              }
              declare module 'dojo/_base/unload' {
              	const unload: dojo._base.Unload;
              	export = unload;
              }
              declare module 'dojo/_base/url' {
              	type Url = dojo._base.Url;
              	const Url: dojo._base.UrlConstructor;
              	export = Url;
              }
              declare module 'dojo/_base/window' {
              	const window: dojo._base.Window;
              	export = window;
              }
              declare module 'dojo/_base/xhr' {
              	const xhr: dojo._base.Xhr;
              	export = xhr;
              }
              declare module 'dojo/AdapterRegistry' {
              	type AdapterRegistry = dojo.AdapterRegistry;
              	const AdapterRegistry: dojo.AdapterRegistryConstructor;
              	export = AdapterRegistry;
              }
              declare module 'dojo/aspect' {
              	const aspect: dojo.Aspect;
              	export = aspect;
              }
              declare module 'dojo/back' {
              	const back: dojo.Back;
              	export = back;
              }
              declare module 'dojo/behavior' {
              	const behavior: dojo.Behavior;
              	export = behavior;
              }
              declare module 'dojo/cache' {
              	const cache: dojo.Cache;
              	export = cache;
              }
              declare module 'dojo/cldr/monetary' {
              	const monetary: dojo.cldr.Monetary;
              	export = monetary;
              }
              declare module 'dojo/cldr/supplemental' {
              	const supplemental: dojo.cldr.Supplemental;
              	export = supplemental;
              }
              declare module 'dojo/colors' {
              	type Color = dojo._base.Color;
              	const Color: dojo._base.ColorConstructor;
              	export = Color;
              }
              declare module 'dojo/cookie' {
              	const cookie: dojo.Cookie;
              	export = cookie;
              }
              declare module 'dojo/currency' {
              	const currency: dojo.Currency;
              	export = currency;
              }
              declare module 'dojo/data/api/Identity' {
              	type Identity<T> = dojo.data.api.Identity<T>;
              	const Identity: dojo.data.api.IdentityConstructor;
              	export = Identity;
              }
              declare module 'dojo/data/api/Item' {
              	type Item = dojo.data.api.Item;
              	const Item: dojo.data.api.ItemConstructor;
              	export = Item;
              }
              declare module 'dojo/data/api/Notification' {
              	type Notification<T> = dojo.data.api.Notification<T>;
              	const Notification: dojo.data.api.NotificationConstructor;
              	export = Notification;
              }
              declare module 'dojo/data/api/Read' {
              	type Read<T> = dojo.data.api.Read<T>;
              	const Read: dojo.data.api.ReadConstructor;
              	export = Read;
              }
              declare module 'dojo/data/api/Request' {
              	type Request = dojo.data.api.Request;
              	const Request: dojo.data.api.RequestConstructor;
              	export = Request;
              }
              declare module 'dojo/data/api/Write' {
              	type Write<T> = dojo.data.api.Write<T>;
              	const Write: dojo.data.api.WriteConstructor;
              	export = Write;
              }
              declare module 'dojo/data/util/filter' {
              	const filter: dojo.data.util.Filter;
              	export = filter;
              }
              declare module 'dojo/data/util/simpleFetch' {
              	const simpleFetch: dojo.data.util.SimpleFetch;
              	export = simpleFetch;
              }
              declare module 'dojo/data/util/sorter' {
              	const sorter: dojo.data.util.Sorter;
              	export = sorter;
              }
              declare module 'dojo/data/ItemFileReadStore' {
              	type ItemFileReadStore<T> = dojo.data.ItemFileReadStore<T>;
              	const ItemFileReadStore: dojo.data.ItemFileReadStoreConstructor;
              	export = ItemFileReadStore;
              }
              declare module 'dojo/data/ItemFileWriteStore' {
              	type ItemFileWriteStore<T> = dojo.data.ItemFileWriteStore<T>;
              	const ItemFileWriteStore: dojo.data.ItemFileWriteStoreConstructor;
              	export = ItemFileWriteStore;
              }
              declare module 'dojo/data/ObjectStore' {
              	type ObjectStore<T> = dojo.data.ObjectStore<T>;
              	const ObjectStore: dojo.data.ObjectStoreConstructor;
              	export = ObjectStore;
              }
              declare module 'dojo/date' {
              	const date: dojo.date.DateBase;
              	export = date;
              }
              declare module 'dojo/date/locale' {
              	const dateLocale: dojo.date.DateLocale;
              	export = dateLocale;
              }
              declare module 'dojo/date/stamp' {
              	const stamp: dojo.date.Stamp;
              	export = stamp;
              }
              declare module 'dojo/debounce' {
              	const debounce: dojo.Debounce;
              	export = debounce;
              }
              declare module 'dojo/Deferred' {
              	type Deferred<T> = dojo.Deferred<T>;
              	const Deferred: dojo.DeferredConstructor;
              	export = Deferred;
              }
              declare module 'dojo/DeferredList' {
              	type DeferredList<T> = dojo.DeferredList<T>;
              	const DeferredList: dojo.DeferredListConstructor;
              	export = DeferredList;
              }
              declare module 'dojo/dnd/autoscroll' {
              	const autoscroll: dojo.dnd.AutoScroll;
              	export = autoscroll;
              }
              declare module 'dojo/dnd/AutoSource' {
              	const AutoSource: dojo.dnd.AutoSourceConstructor;
              	export = AutoSource;
              }
              declare module 'dojo/dnd/Avatar' {
              	type Avatar = dojo.dnd.Avatar;
              	const Avatar: dojo.dnd.AvatarConstructor;
              	export = Avatar;
              }
              declare module 'dojo/dnd/common' {
              	const common: dojo.dnd.Common;
              	export = common;
              }
              declare module 'dojo/dnd/Container' {
              	type Container = dojo.dnd.Container;
              	const Container: dojo.dnd.ContainerConstructor;
              	export = Container;
              }
              declare module 'dojo/dnd/Manager' {
              	type Manager = dojo.dnd.Manager;
              	const Manager: dojo.dnd.ManagerConstructor;
              	export = Manager;
              }
              declare module 'dojo/dnd/move' {
              	const Move: dojo.dnd.Move;
              	export = Move;
              }
              declare module 'dojo/dnd/Moveable' {
              	type Moveable = dojo.dnd.Moveable;
              	const Moveable: dojo.dnd.Moveable;
              	export = Moveable;
              }
              declare module 'dojo/dnd/Mover' {
              	type Mover = dojo.dnd.Mover;
              	const Mover: dojo.dnd.MoverConstructor;
              	export = Mover;
              }
              declare module 'dojo/dnd/Selector' {
              	type Selector = dojo.dnd.Selector;
              	const Selector: dojo.dnd.SelectorConstructor;
              	export = Selector;
              }
              declare module 'dojo/dnd/Source' {
              	type Source = dojo.dnd.Source;
              	const Source: dojo.dnd.SourceConstructor;
              	export = Source;
              }
              declare module 'dojo/dnd/Target' {
              	type Target = dojo.dnd.Target;
              	const Target: dojo.dnd.TargetConstructor;
              	export = Target;
              }
              declare module 'dojo/dnd/TimedMoveable' {
              	type TimedMoveable = dojo.dnd.TimedMoveable;
              	const TimedMoveable: dojo.dnd.TimedMoveableConstructor;
              	export = TimedMoveable;
              }
              declare module 'dojo/dojo' {
              	const require: dojo.Require;
              	export = require;
              }
              declare module 'require' {
              	const require: dojo.Require;
              	export = require;
              }
              declare module 'dojo/dom' {
              	const dom: dojo.Dom;
              	export = dom;
              }
              declare module 'dojo/dom-attr' {
              	const domAttr: dojo.DomAttr;
              	export = domAttr;
              }
              declare module 'dojo/dom-class' {
              	const domClass: dojo.DomClass;
              	export = domClass;
              }
              declare module 'dojo/dom-construct' {
              	const domConstruct: dojo.DomConstruct;
              	export = domConstruct;
              }
              declare module 'dojo/dom-form' {
              	const domForm: dojo.DomForm;
              	export = domForm;
              }
              declare module 'dojo/dom-geometry' {
              	const domGeom: dojo.DomGeometry;
              	export = domGeom;
              }
              declare module 'dojo/dom-prop' {
              	const domProp: dojo.DomProp;
              	export = domProp;
              }
              declare module 'dojo/dom-style' {
              	const domStyle: dojo.DomStyle;
              	export = domStyle;
              }
              declare module 'dojo/domReady' {
              	const domReady: dojo.DomReady;
              	export = domReady;
              }
              declare module 'dojo/domReady!' {
              	const callback: any;
              	export = callback;
              }
              declare module 'dojo/errors/CancelError' {
              	type CancelError = dojo.errors.CancelError;
              	const CancelError: dojo.errors.CancelErrorConstructor;
              	export = CancelError;
              }
              declare module 'dojo/errors/create' {
              	const create: dojo.errors.Create;
              	export = create;
              }
              declare module 'dojo/errors/RequestError' {
              	type RequestError = dojo.errors.RequestError;
              	const RequestError: dojo.errors.RequestErrorConstructor;
              	export = RequestError;
              }
              declare module 'dojo/errors/RequestTimeoutError' {
              	type RequestTimeoutError = dojo.errors.RequestError;
              	const RequestTimeoutError: dojo.errors.RequestTimeoutErrorConstructor;
              	export = RequestTimeoutError;
              }
              declare module 'dojo/Evented' {
              	type Evented = dojo.Evented;
              	const Evented: dojo.EventedConstructor;
              	export = Evented;
              }
              declare module 'dojo/gears' {
              	const gears: dojo.Gears;
              	export = gears;
              }
              declare module 'dojo/has' {
              	const has: dojo.Has;
              	export = has;
              }
              declare module 'dojo/hash' {
              	const hash: dojo.Hash;
              	export = hash;
              }
              declare module 'dojo/hccss' {
              	const hccss: dojo.Has;
              	export = hccss;
              }
              declare module 'dojo/html' {
              	const html: dojo.Html;
              	export = html;
              }
              declare module 'dojo/i18n' {
              	const i18n: dojo.I18n;
              	export = i18n;
              }
              declare module 'dojo/io/iframe' {
              	const iframe: dojo.io.IFrame;
              	export = iframe;
              }
              declare module 'dojo/io/script' {
              	const script: dojo.io.Script;
              	export = script;
              }
              declare module 'dojo/io-query' {
              	const ioQuery: dojo.IoQuery;
              	export = ioQuery;
              }
              declare module 'dojo/json' {
              	const json: dojo.Json;
              	export = json;
              }
              declare module 'dojo/keys' {
              	const keys: dojo.Keys;
              	export = keys;
              }
              declare module 'dojo/loadInit' {
              	const loadInit: dojo.LoadInit;
              	export = loadInit;
              }
              declare module 'dojo/loadInit!' {
              	const loadInit: (mid: string, require: any, loaded: (...modules: any[]) => void) => void;
              	export = loadInit;
              }
              declare module 'dojo/main' {
              	const main: dojo._base.Dojo;
              	export = main;
              }
              declare module 'dojo/mouse' {
              	const mouse: dojo.Mouse;
              	export = mouse;
              }
              declare module 'dojo/NodeList' {
              	type NodeList<T extends Node> = dojo.NodeList<T>;
              	const NodeList: dojo.NodeListConstructor;
              	export = NodeList;
              }
              declare module 'dojo/number' {
              	const value: dojo.Number;
              	export = value;
              }
              declare module 'dojo/on' {
              	const on: dojo.On;
              	export = on;
              }
              declare module 'dojo/on/asyncEventListener' {
              	const asyncEventListener: dojo.on.AsyncEventListener;
              	export = asyncEventListener;
              }
              declare module 'dojo/on/debounce' {
              	const debounce: dojo.on.Debounce;
              	export = debounce;
              }
              declare module 'dojo/on/throttle' {
              	const throttle: dojo.on.Throttle;
              	export = throttle;
              }
              declare module 'dojo/parser' {
              	const parser: dojo.Parser;
              	export = parser;
              }
              declare module 'dojo/promise/all' {
              	const all: dojo.promise.All;
              	export = all;
              }
              declare module 'dojo/promise/first' {
              	const first: dojo.promise.First;
              	export = first;
              }
              declare module 'dojo/promise/instrumentation' {
              	const instrumentation: dojo.promise.Instrumentation;
              	export = instrumentation;
              }
              declare module 'dojo/promise/Promise' {
              	type Promise<T> = dojo.promise.Promise<T>;
              	const Promise: dojo.promise.PromiseConstructor;
              	export = Promise;
              }
              declare module 'dojo/promise/tracer' {
              	const tracer: dojo.promise.Tracer;
              	export = tracer;
              }
              declare module 'dojo/query' {
              	const query: dojo.Query;
              	export = query;
              }
              /* modules for included selector engines */
              declare module 'dojo/query!acme' {
              	const query: dojo.Query;
              	export = query;
              }
              declare module 'dojo/query!lite' {
              	const query: dojo.Query;
              	export = query;
              }
              declare module 'dojo/ready' {
              	const ready: dojo.Ready;
              	export = ready;
              }
              declare module 'dojo/regexp' {
              	const regexp: dojo.RegExpModule;
              	export = regexp;
              }
              declare module 'dojo/request' {
              	const request: dojo.request.Request;
              	export = request;
              }
              declare module 'dojo/request/default' {
              	const def: dojo.request.Default;
              	export = def;
              }
              declare module 'dojo/request/default!' {
              	const def: dojo.request.Request;
              	export = def;
              }
              declare module 'dojo/request/handlers' {
              	const handlers: dojo.request.Handlers;
              	export = handlers;
              }
              declare module 'dojo/request/iframe' {
              	const iframe: dojo.request.IFrame;
              	export = iframe;
              }
              declare module 'dojo/request/node' {
              	const node: dojo.request.Node;
              	export = node;
              }
              declare module 'dojo/request/registry' {
              	const registry: dojo.request.Registry;
              	export = registry;
              }
              declare module 'dojo/request/script' {
              	const script: dojo.request.Script;
              	export = script;
              }
              declare module 'dojo/request/util' {
              	const util: dojo.request.Util;
              	export = util;
              }
              declare module 'dojo/request/watch' {
              	const watch: dojo.request.Watch;
              	export = watch;
              }
              declare module 'dojo/request/xhr' {
              	const xhr: dojo.request.Xhr;
              	export = xhr;
              }
              declare module 'dojo/require' {
              	const require: dojo.RequirePlugin;
              	export = require;
              }
              declare module 'dojo/robot' {
              	const robot: dojo.Robot;
              	export = robot;
              }
              declare module 'dojo/robotx' {
              	const robotx: dojo.RobotX;
              	export = robotx;
              }
              declare module 'dojo/router' {
              	const router: dojo.router.RouterBase;
              	export = router;
              }
              declare module 'dojo/router/RouterBase' {
              	type RouterBase = dojo.router.RouterBase;
              	const RouterBase: dojo.router.RouterBaseConstructor;
              	export = RouterBase;
              }
              declare module 'dojo/rpc/JsonpService' {
              	type JsonpService<T> = dojo.rpc.JsonpService<T>;
              	const JsonpService: dojo.rpc.JsonpServiceConstructor;
              	export = JsonpService;
              }
              declare module 'dojo/rpc/JsonService' {
              	type JsonService<T> = dojo.rpc.JsonService<T>;
              	const JsonService: dojo.rpc.JsonServiceConstructor;
              	export = JsonService;
              }
              declare module 'dojo/rpc/RpcService' {
              	type RpcService<T> = dojo.rpc.RpcService<T>;
              	const RpcService: dojo.rpc.RpcServiceConstructor;
              	export = RpcService;
              }
              declare module 'dojo/selector/_loader' {
              	const loader: dojo.selector.Loader;
              	export = loader;
              }
              declare module 'dojo/selector/_loader!' {
              	const lite: dojo.selector.LiteQueryEnegine;
              	export = lite;
              }
              declare module 'dojo/selector/_loader!acme' {
              	const acme: dojo.selector.AcmeQueryEngine;
              	export = acme;
              }
              declare module 'dojo/selector/_loader!lite' {
              	const lite: dojo.selector.LiteQueryEnegine;
              	export = lite;
              }
              declare module 'dojo/selector/acme' {
              	const acme: dojo.selector.AcmeQueryEngine;
              	export = acme;
              }
              declare module 'dojo/selector/lite' {
              	const lite: dojo.selector.LiteQueryEnegine;
              	export = lite;
              }
              declare module 'dojo/sniff' {
              	const sniff: dojo.Has;
              	export = sniff;
              }
              declare module 'dojo/Stateful' {
-             	type Stateful<T = any> = dojo.Stateful<any>;
+             	type Stateful<T = any> = dojo.Stateful<T>;
              	const Stateful: dojo.StatefulConstructor;
              	export = Stateful;
              }
              declare module 'dojo/store/api/Store' {
              	type Store<T extends Object, Q extends string | Object | Function, O extends dojo.store.api.QueryOptions>  = dojo.store.api.Store<T, Q, O>;
              	const Store: dojo.store.api.StoreConstructor;
              	export = Store;
              }
              declare module 'dojo/store/util/QueryResults' {
              	const QueryResults: dojo.store.util.QueryResultsFunction;
              	export = QueryResults;
              }
              declare module 'dojo/store/util/SimpleQueryEngine' {
              	const SimpleQueryEngine: dojo.store.util.SimpleQueryEngine;
              	export = SimpleQueryEngine;
              }
              declare module 'dojo/store/Cache' {
              	const Cache: dojo.store.Cache;
              	export = Cache;
              }
              declare module 'dojo/store/DataStore' {
              	type DataStore<T extends Object> = dojo.store.DataStore<T>;
              	const DataStore: dojo.store.DataStoreConstructor;
              	export = DataStore;
              }
              declare module 'dojo/store/JsonRest' {
              	type JsonRest<T extends object, Q extends dojo.store.api.BaseQueryType, O extends dojo.store.JsonRestQueryOptions> = dojo.store.JsonRest<T, Q, O>;
              	const JsonRest: dojo.store.JsonRestConstructor;
              	export = JsonRest;
              }
              declare module 'dojo/store/Memory' {
              	type Memory<T extends Object> = dojo.store.Memory<T>;
              	const Memory: dojo.store.MemoryConstructor;
              	export = Memory;
              }
              declare module 'dojo/store/Observable' {
              	const Observerable: dojo.store.Observable;
              	export = Observerable;
              }
              declare module 'dojo/string' {
              	const value: dojo.String;
              	export = value;
              }
              declare module 'dojo/text' {
              	const text: dojo.Text;
              	export = text;
              }
              declare module 'dojo/throttle' {
              	const throttle: dojo.Throttle;
              	export = throttle;
              }
              declare module 'dojo/topic' {
              	const hub: dojo.Topic;
              	export = hub;
              }
              declare module 'dojo/touch' {
              	const touch: dojo.Touch;
              	export = touch;
              }
              declare module 'dojo/uacss' {
              	const uacss: dojo.Has;
              	export = uacss;
              }
              declare module 'dojo/when' {
              	const when: dojo.When;
              	export = when;
              }
              declare module 'dojo/window' {
              	const window: dojo.WindowModule;
              	export = window;
              }
              declare module 'dojo/i18n!*' {
              	const value: any;
              	export = value;
              }
              declare module 'dojo/text!*' {
              	const content: string;
              	export = content;
              }

dojo-typings/src/test/ts/StatefulTests.ts +7 -2

-             import Stateful = require("dojo/Stateful");
+             import * as Stateful from "dojo/Stateful";
+             import { StatefulAttrs, watch } from "./traits";
              interface ScheduleAttrs {
                  title: string;
                  duration: number;
              }
              declare class Schedule extends Stateful<ScheduleAttrs> {
                  title: string;
              }
              const model = new Schedule({duration: 10, title: "Test event"});
              model.get("title");
              model.get("duration");
-             model.set("duration", 12);
  No newline at end of file
+             model.set("duration", 12);
+             watch(model, "duration", v => v);
+             declare const o : StatefulAttrs<Schedule>;
  No newline at end of file

dojo-typings/src/test/ts/StoreTests.ts +8 -10

-             import Memory = require("dojo/store/Memory");
-             import Observable = require("dojo/store/Observable");
+             import * as Memory from "dojo/store/Memory";
+             import * as Observable from "dojo/store/Observable";
              interface Schedule {
                  id?: string;
                  title: string;
                  duration: number;
              }
              declare const store: dojo.store.api.Store<Schedule>;
              const observable = new Observable(store);
              const mem = new Memory<Schedule>();
-             (async () => {
-                 observable.query().observe(() => {});
-                 store.query().forEach(() => {});
-                 const total = await store.query().total;
-                 const result = await store.query();
+             observable.query().observe(() => { });
+             store.query().forEach(() => { });
+             const total = await store.query().total;
+             const result = await store.query();
-                 mem.query();
+             mem.query();
-                 mem.add({duration: 10, title: "Test event"});
-             })();
  No newline at end of file
+             mem.add({ duration: 10, title: "Test event" });

dojo-typings/src/test/ts/_WidgetTests.ts +30 -6

-             import _WidgetBase = require("dijit/_WidgetBase");
+             import * as _WidgetBase from "dijit/_WidgetBase";
+             import { watch } from "./traits";
              interface ScheduleWidgetAttrs {
                  data: string[];
              }
-             declare const w0: _WidgetBase<ScheduleWidgetAttrs>;
+             interface ScheduleWidgetEvents {
+                 "scheduled": Event & {
+                     detail: {
+                         startDate: Date,
+                         endDate: Date
+                     }
+                 };
+             }
-             w0.get("data");
-             declare class ScheduleWidget extends _WidgetBase {
+             declare class ScheduleWidget extends _WidgetBase<ScheduleWidgetAttrs, ScheduleWidgetEvents> {
                  data: string[];
              }
              const w = new ScheduleWidget({title: "Year schedule", data: ["a", "b"] });
-             w.get("data");
  No newline at end of file
+             w.get("data");
+             w.watch((p, o, n) => [p,o,n]);
+             w.watch("data", (p, o, n) => [p,o,n]);
+             watch(w, "title", v => String(v) );
+             watch(w, "data", v => String(v) );
+             w.emit("scheduled", { detail: { startDate: new Date(), endDate: new Date()} });
+             w.emit("click", {} );
+             w.emit("click", {} );
+             w.emit("some-extra-event", {});
+             w.on("click", e => e);
+             w.on("some-extra-event", e => e);

dojo-typings/src/test/tsconfig.json +3 -1

              {
                  "extends": "../tsconfig",
                  "compilerOptions": {
                      "baseUrl": ".",
                      "rootDir": "ts",
                      "rootDirs": [
                          "ts",
+                         "typings",
                          "../main/ts"
                      ],
                      "types": [
                          "requirejs",
                          "../main/typings/dojo/modules",
                          "../main/typings/dijit/modules"
                      ],
-                     "module": "amd"
+                     "module": "ESNext",
+                     "target": "ESNext"
                  },
                  "include": [
                      "typings/**/*.ts",
                      "ts/**/*.ts",
                      "ts/**/*.tsx"
                  ]
              }
  No newline at end of file

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages