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			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;
+                    new <A = {}, E extends { [k in keyof E]: Event } = {}>(params?: Partial<_WidgetBase<E> & A>, srcNodeRef?: dojo.NodeOrString): _WidgetBase<E> & dojo._base.DeclareCreatedObject;
-                    prototype: _WidgetBase;
+                    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 * as Memory from "dojo/store/Memory";
-            import Observable = require("dojo/store/Observable");
+            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(() => { });
-                observable.query().observe(() => {});
+            store.query().forEach(() => { });
-                store.query().forEach(() => {});
+            const total = await store.query().total;
-                const total = await store.query().total;
+            const result = await store.query();
-                const result = await store.query();
-                mem.query();
+            mem.query();
-                mem.add({duration: 10, title: "Test event"});
+            mem.add({ duration: 10, title: "Test event" });
-            })();
  No newline at end of file

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

@@ -1,17 +1,41
1	import _WidgetBase = ~~require~~("dijit/_WidgetBase");	1	import * as _WidgetBase from "dijit/_WidgetBase";
		2	import { watch } from "./traits";
2		3
3	interface ScheduleWidgetAttrs {	4	interface ScheduleWidgetAttrs {
4	data: string[];	5	data: string[];
5	}	6	}
6		7
7	declare const w0: _WidgetBase<ScheduleWidgetAttrs>;	8	interface ScheduleWidgetEvents {
		9	"scheduled": Event & {
		10	detail: {
		11	startDate: Date,
		12	endDate: Date
		13	}
		14	};
		15	}
8		16
9	w0.get("data");	17	declare class ScheduleWidget extends _WidgetBase<ScheduleWidgetAttrs, ScheduleWidgetEvents> {
10
11	declare class ScheduleWidget extends _WidgetBase {
12	data: string[];	18	data: string[];
13	}	19	}
14		20
15	const w = new ScheduleWidget({title: "Year schedule", data: ["a", "b"] });	21	const w = new ScheduleWidget({title: "Year schedule", data: ["a", "b"] });
16		22
17	w.get("data"); No newline at end of file	23	w.get("data");
		24
		25	w.watch((p, o, n) => [p,o,n]);
		26
		27	w.watch("data", (p, o, n) => [p,o,n]);
		28
		29	watch(w, "title", v => String(v) );
		30	watch(w, "data", v => String(v) );
		31
		32	w.emit("scheduled", { detail: { startDate: new Date(), endDate: new Date()} });
		33
		34	w.emit("click", {} );
		35
		36	w.emit("click", {} );
		37
		38	w.emit("some-extra-event", {});
		39
		40	w.on("click", e => e);
		41	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"
                 ]
             }

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