# HG changeset patch
# User cin
# Date 2021-08-31 13:00:12
# Node ID c7a87ad80f91a34a60ac73554cfaec176512772a
# Parent  0b28c6ab359fb235d729554d5cf556e4181c41f3

Fixed build script, added dgrid, added dstore typings.

diff --git a/dojo-typings/build.gradle b/dojo-typings/build.gradle
--- a/dojo-typings/build.gradle
+++ b/dojo-typings/build.gradle
@@ -49,12 +49,20 @@ npmPackMeta {
     }
 }
 
+task npmPackTypings(type: Copy) {
+    dependsOn typings
+    
+    npmPackContents.dependsOn it
+
+    from typescript.typingsDir
+    into npm.packageDir
+}
+
 task printVersion {
     doLast {
         println "packageName: ${npmPackMeta.metadata.get().name}";
         println "version: $version";
         println "target: $typescript.compilerOptions.target";
         println "module: $typescript.compilerOptions.module";
-        println "symbols: $symbols";
     }
 }
\ No newline at end of file
diff --git a/dojo-typings/src/main/typings/dgrid/dgrid.d.ts b/dojo-typings/src/main/typings/dgrid/dgrid.d.ts
new file mode 100644
--- /dev/null
+++ b/dojo-typings/src/main/typings/dgrid/dgrid.d.ts
@@ -0,0 +1,753 @@
+/// <reference path="../dstore/dstore.d.ts" />
+
+declare module dgrid {
+	export interface Constructor<T, U> extends dojo._base.DeclareConstructor<T> {
+		new (kwArgs?: U, srcNodeRef?: HTMLElement | string): T;
+
+		createSubclass<T1, U1, T2, U2, T3, U3, T4, U4, X>(mixins: [Constructor<T1, U1>, Constructor<T2, U2>, Constructor<T3, U3>, Constructor<T4, U4>], props: X): Constructor<T & T1 & T2 & T3 & T4 & X, U & U1 & U2 & U3 & T4>;
+		createSubclass<T1, U1, T2, U2, T3, U3, X>(mixins: [Constructor<T1, U1>, Constructor<T2, U2>, Constructor<T3, U3>], props: X): Constructor<T & T1 & T2 & T3 & X, U & U1 & U2 & U3>;
+		createSubclass<T1, U1, T2, U2, X>(mixins: [Constructor<T1, U1>, Constructor<T2, U2>], props: X): Constructor<T & T1 & T2 & X, U & U1 & U2>;
+		createSubclass<T1, U1, X>(mixins: [Constructor<T1, U1>], props: X): Constructor<T & T1 & X, U & U1>;
+		createSubclass<T1, U1, X>(mixins: Constructor<T1, U1>, props: X): Constructor<T & T1 & X, U & U1>;
+		createSubclass<T1, U1, T2, U2, T3, U3, T4, U4>(mixins: [Constructor<T1, U1>, Constructor<T2, U2>, Constructor<T3, U3>, Constructor<T4, U4>]): Constructor<T & T1 & T2 & T3 & T4, U & U1 & U2 & U3 & T4>;
+		createSubclass<T1, U1, T2, U2, T3, U3>(mixins: [Constructor<T1, U1>, Constructor<T2, U2>, Constructor<T3, U3>]): Constructor<T & T1 & T2 & T3, U & U1 & U2 & U3>;
+		createSubclass<T1, U1, T2, U2>(mixins: [Constructor<T1, U1>, Constructor<T2, U2>]): Constructor<T & T1 & T2, U & U1 & U2>;
+		createSubclass<T1, U1>(mixins: [Constructor<T1, U1>]): Constructor<T & T1, U & U1>;
+		createSubclass<T1, U1>(mixins: Constructor<T1, U1>): Constructor<T & T1, U & U1>;
+		createSubclass<X>(mixins: any, props: X): Constructor<T & X, U>;
+	}
+}
+
+declare module 'dgrid/CellSelection' {
+	import Selection = require('dgrid/Selection');
+	import Grid = require('dgrid/Grid');
+
+	interface CellSelection extends Selection {
+		isSelected(target: Grid.CellArg, columnId?: string): boolean;
+		clearSelection(): void;
+	}
+
+	interface CellSelectionConstructor extends dgrid.Constructor<CellSelection, Selection.KwArgs> {}
+
+	const CellSelection: CellSelectionConstructor;
+
+	export = CellSelection;
+}
+
+declare module 'dgrid/ColumnSet' {
+	import Grid = require('dgrid/Grid');
+
+	interface ColumnSet {
+		styleColumnSet(columnsetId: string, css: string): dojo.Handle;
+	}
+
+	module ColumnSet {
+		export interface KwArgs extends Grid.KwArgs {
+			columnSets?: Array<Array<Grid.Column>>;
+		}
+	}
+
+	interface ColumnSetConstructor extends dgrid.Constructor<ColumnSet, ColumnSet.KwArgs> {}
+
+	const ColumnSet: ColumnSetConstructor;
+
+	export = ColumnSet;
+}
+
+declare module 'dgrid/Editor' {
+	import Grid = require('dgrid/Grid');
+	import OnDemandGrid = require('dgrid/OnDemandGrid');
+
+	interface Editor {
+		edit(cell: Grid.Cell<any> | HTMLElement | Event): void;
+	}
+
+	module Editor {
+		export interface Column extends Grid.Column {
+			autoSave?: boolean;
+			autoSelect?: boolean;
+			dismissOnEnter?: boolean;
+			editor?: string | dojo._base.DeclareConstructor<any>;
+			editOn?: string;
+			editorArgs?: Object;
+
+			canEdit?(object: any, value: any): boolean;
+		}
+		export type ColumnSpec = { [key: string]: Column | string; } | Column[];
+		export interface KwArgs extends OnDemandGrid.KwArgs {
+			columns?: ColumnSpec;
+			subRows?: Array<Column[]>;
+		}
+	}
+
+	interface EditorConstructor extends dgrid.Constructor<Editor, Editor.KwArgs> {}
+
+	const Editor: EditorConstructor;
+
+	export = Editor;
+}
+
+declare module 'dgrid/Grid' {
+	import List = require('dgrid/List');
+
+	interface Grid extends List {
+		columns: { [ key: string ]: Grid.Column } | Array<Grid.Column>;
+		hasNeutralSort: boolean;
+		cellNavigation: boolean;
+		formatterScope: any;
+
+		column(target: any): Grid.Column;
+		cell(target: Grid.CellArg, columnId?: string): Grid.Cell<any>;
+		left(target: Grid.Cell<any> | Grid.CellArg, steps?: number): Grid.Cell<any>;
+		right(target: Grid.Cell<any> | Grid.CellArg, steps?: number): Grid.Cell<any>;
+		styleColumn(columnId: string, css: string): dojo.Handle;
+		updateSortArrow(sort: any, updateSort?: boolean): void;
+	}
+
+	module Grid {
+		export type CellArg = List.RowArg;
+		export interface Cell<T> {
+			row: List.Row<T>;
+			column: Column;
+			element: HTMLElement;
+		}
+		export interface Column {
+			field?: string;
+			id?: string | number;
+			label?: string;
+			className?: string;
+			colSpan?: number;
+			rowSpan?: number;
+			sortable?: boolean;
+			formatter?: string | Formatter;
+
+			get?(item: any): any;
+			set?(item: any): any;
+			renderCell?(object: any, value: any, node: HTMLElement): (HTMLElement | void);
+			renderHeaderCell?(node: HTMLElement): (HTMLElement | void);
+		}
+		export type ColumnSpec = { [key: string]: Column | string; } | Column[];
+		export type Formatter = (value: any, object: any) => string;
+		export interface KwArgs extends List.KwArgs {
+			columns?: ColumnSpec;
+			subRows?: Array<Column[]>;
+			formatterScope?: any;
+			hasNeutralSort?: boolean;
+			cellNavigation?: boolean;
+		}
+	}
+
+	interface GridConstructor extends dgrid.Constructor<Grid, Grid.KwArgs> {
+		appendIfNode(parent: HTMLElement, subNode?: any): void;
+	}
+
+	const Grid: GridConstructor;
+
+	export = Grid;
+}
+
+declare module 'dgrid/GridFromHtml' {
+	import Grid = require('dgrid/Grid');
+
+	interface GridFromHtml extends Grid {}
+
+	interface GridFromHtmlConstructor extends dgrid.Constructor<GridFromHtml, Grid.KwArgs> {
+		utils: {
+			getBoolFromAttr(node: Node, attr: string): boolean;
+			getNumFromAttr(node: Node, attr: string): number;
+			getPropsFromNode(node: Node): any;
+			getColumnFromCell(node: Node): Grid.Column;
+		};
+	}
+
+	const GridFromHtml: GridFromHtmlConstructor;
+
+	export = GridFromHtml;
+}
+
+declare module 'dgrid/GridWithColumnSetsFromHtml' {
+	import Grid = require('dgrid/Grid');
+	import GridFromHtml = require('dgrid/GridFromHtml');
+	import ColumnSet = require('dgrid/ColumnSet');
+
+	interface GridWithColumnSetsFromHtml extends GridFromHtml, ColumnSet {}
+
+	module GridWithColumnSetsFromHtml {
+		export interface KwArgs extends Grid.KwArgs, ColumnSet.KwArgs {}
+	}
+
+	interface GridWithColumnSetsFromHtmlConstructor extends dgrid.Constructor<GridWithColumnSetsFromHtml, GridWithColumnSetsFromHtml.KwArgs> {}
+
+	const GridWithColumnSetsFromHtml: GridWithColumnSetsFromHtmlConstructor;
+
+	export = GridWithColumnSetsFromHtml;
+}
+
+declare module 'dgrid/Keyboard' {
+	interface Keyboard {
+		cellNavigation: boolean;
+		pageSkip: number;
+		keyMap: Keyboard.KeyMap;
+		headerKeyMap: Keyboard.KeyMap;
+
+		addKeyHandler(key: number, callback: Function, isHeader?: boolean): dojo.Handle;
+		focus(target: any): void;
+		focusHeader(target: any): void;
+	}
+
+	module Keyboard {
+		export interface KeyMap {
+			[ key: number ]: Function;
+		}
+
+		export interface KwArgs {
+			cellNavigation?: boolean;
+			pageSkip?: number;
+			keyMap?: KeyMap;
+			headerKeyMap?: KeyMap;
+		}
+	}
+
+	interface KeyboardConstructor extends dgrid.Constructor<Keyboard, Keyboard.KwArgs> {
+		defaultHeaderKeyMap: Keyboard.KeyMap;
+		defaultKeyMap: Keyboard.KeyMap;
+
+		moveFocusVertical: (event: KeyboardEvent, steps: number) => void;
+	}
+
+	const Keyboard: KeyboardConstructor;
+
+	export = Keyboard;
+}
+
+declare module 'dgrid/List' {
+	interface List {
+        id: string;
+        
+		readonly domNode: HTMLElement;
+
+		tabableHeader: boolean;
+		showHeader: boolean;
+		showFooter: boolean;
+		maintainOddEven: boolean;
+		cleanAddedRules: boolean;
+		addUiClasses: boolean;
+		highlightDuration: number;
+		resizeThrottleDelay: number;
+		resizeThrottleMethod: List.ThrottleMethod;
+		sort: any;
+
+        params: any;
+
+		create(params: any, srcNodeRef?: HTMLElement): void;
+		buildRendering(): void;
+		postCreate(): void;
+
+        postMixInProperties(): void;
+
+		get(key: string): any;
+
+		set(key: string, value: any): this;
+		set(kwArgs: any): this;
+
+		addCssRule(selector: string, css: string): dojo.Handle;
+		adjustRowIndices(firstRow: HTMLElement): void;
+		cleanup(): void;
+		configStructure(): void;
+		destroy(): void;
+		down(row: List.Row<any> | List.RowArg, steps?: number): List.Row<any>;
+		getScrollPosition(): { x: number; y: number; };
+		highlightRow(rowElement: HTMLElement | List.Row<any>, delay?: number): void;
+		insertRow(object: any, parent: HTMLElement, beforeNode: Node, i: number, options?: any): HTMLElement;
+
+		on(type: string | dojo.ExtensionEvent, listener: EventListener): dojo.Handle;
+
+		_onNotification(rows?: any[], object?: any, from?: number, to?: number): void;
+		refresh(): void;
+		removeRow(rowElement: any, preserveDom?: boolean): void;
+		renderArray(results: any[], beforeNode?: Node, options?: any): HTMLElement;
+		renderHeader(): void;
+		renderRow(value: any, options?: Object): HTMLElement;
+
+		row(target: List.RowArg): List.Row<any>;
+		resize(): void;
+		scrollTo(options: { x?: number; y?: number; }): void;
+		startup(): void;
+		up(row: List.Row<any> | List.RowArg, steps?: number): List.Row<any>;
+	}
+
+	module List {
+		export type RowArg = Event | HTMLElement | Object | string | number;
+		export interface Row<T> {
+			id: string;
+			data: T;
+			element: HTMLElement;
+
+			remove(): void;
+		}
+
+		export interface KwArgs {
+			tabableHeader?: boolean;
+			showHeader?: boolean;
+			showFooter?: boolean;
+			maintainOddEven?: boolean;
+			cleanAddedRules?: boolean;
+			addUiClasses?: boolean;
+			highlightDuration?: number;
+			resizeThrottleDelay?: number;
+			resizeThrottleMethod?: ThrottleMethod;
+			sort?: any;
+		}
+
+		export type ThrottleFunction = (callback: Function, delay: number) => Function;
+		export type ThrottleMethod = 'debounce' | 'throttle' | 'throttleDelayed' | ThrottleFunction;
+	}
+
+	interface ListConstructor extends dgrid.Constructor<List, List.KwArgs> {}
+
+	const List: ListConstructor;
+
+	export = List;
+}
+
+declare module 'dgrid/OnDemandGrid' {
+	import Grid = require('dgrid/Grid');
+	import OnDemandList = require('dgrid/OnDemandList');
+
+	interface OnDemandGrid extends Grid, OnDemandList {
+		refresh(options?: any): dojo.promise.Promise<any[]>;
+	}
+
+	module OnDemandGrid {
+		export interface KwArgs extends Grid.KwArgs, OnDemandList.KwArgs {}
+	}
+
+	interface OnDemandGridConstructor extends dgrid.Constructor<OnDemandGrid, OnDemandGrid.KwArgs> {}
+
+	const OnDemandGrid: OnDemandGridConstructor;
+	export = OnDemandGrid;
+}
+
+declare module 'dgrid/OnDemandList' {
+	import List = require('dgrid/List');
+	import StoreMixin = require('dgrid/_StoreMixin');
+
+	interface OnDemandList extends List, StoreMixin {
+		refresh(options?: any): dojo.promise.Promise<any[]>;
+	}
+
+	module OnDemandList {
+		export interface KwArgs extends List.KwArgs, StoreMixin.KwArgs {
+			minRowsPerPage?: number;
+			maxRowsPerPage?: number;
+			maxEmptySpace?: number;
+			bufferRows?: number;
+			farOffRemoval?: number;
+			queryRowsOverlap?: number;
+			pagingMethod?: string;
+			pagingDelay?: number;
+			keepScrollPosition?: boolean;
+			rowHeight?: number;
+		}
+	}
+
+	interface OnDemandListConstructor extends dgrid.Constructor<OnDemandList, OnDemandList.KwArgs> {}
+
+	const OnDemandList: OnDemandListConstructor;
+
+	export = OnDemandList;
+}
+
+declare module 'dgrid/Selection' {
+	import List = require('dgrid/List');
+
+	interface Selection {
+		selectionMode: Selection.Mode;
+		selection: { [key: string]: boolean; };
+
+		select(row: List.Row<any> | List.RowArg, toRow?: List.Row<any> | List.RowArg, value?: boolean): void;
+		deselect(row: List.Row<any> | List.RowArg, toRow?: List.Row<any> | List.RowArg): void;
+		clearSelection(exceptId?: any, dontResetLastSelected?: boolean): void;
+		selectAll(): void;
+		isSelected(row: List.Row<any> | List.RowArg): boolean;
+	}
+
+	module Selection {
+		export type Mode = 'none' | 'multiple' | 'single' | 'extended';
+		export interface KwArgs {
+			selectionDelegate?: string;
+			selectionEvents?: string;
+			selectionTouchEvents?: string;
+			deselectOnRefresh?: boolean;
+			allowSelectAll?: boolean;
+			selectionMode?: Mode;
+			allowTextSelection?: boolean;
+		}
+	}
+
+	interface SelectionConstructor extends dgrid.Constructor<Selection, Selection.KwArgs> {}
+
+	const Selection: SelectionConstructor;
+
+	export = Selection;
+}
+
+declare module 'dgrid/Selector' {
+	import Selection = require('dgrid/Selection');
+
+	export = Selection;
+}
+
+declare module 'dgrid/_StoreMixin' {
+	interface StoreMixin {
+		get(key: string): any;
+
+		revert(): void;
+		save(): dojo.promise.Promise<{ [ key: string ]: any; }>;
+		updateDirty(id: string, field: string, value: any): void;
+	}
+
+	module StoreMixin {
+		export interface KwArgs {
+			collection?: dstore.Collection<any>;
+			shouldTrackCollection?: boolean;
+			getBeforePut?: boolean;
+			noDataMessage?: string;
+			loadingMessage?: string;
+		}
+	}
+
+	interface StoreMixinConstructor extends dgrid.Constructor<StoreMixin, StoreMixin.KwArgs> {}
+
+	const StoreMixin: StoreMixinConstructor;
+
+	export = StoreMixin;
+}
+
+declare module 'dgrid/Tree' {
+	import List = require('dgrid/List');
+	import Grid = require('dgrid/Grid');
+
+	interface Tree {
+		expand(target: List.Row<any> | List.RowArg, expand?: boolean): dojo.promise.Promise<any>;
+		shouldExpand(row: List.Row<any>, level: number, previouslyExpanded: boolean): boolean;
+	}
+
+	module Tree {
+		export interface Column extends Grid.Column {
+			expandOn?: string;
+			renderExpando?: boolean | RenderExpando;
+		}
+		export type ColumnSpec = { [key: string]: Column | string; } | Column[];
+		export interface KwArgs extends Grid.KwArgs {
+			columns?: ColumnSpec;
+			subRows?: Array<Column[]>;
+			collapseOnRefresh?: boolean;
+			enableTreeTransitions?: boolean;
+			treeIndentWidth?: number;
+		}
+		export type RenderExpando = (level: number, mayHaveChildren: boolean, expanded: boolean, item: any) => HTMLElement;
+	}
+
+	interface TreeConstructor extends dgrid.Constructor<Tree, Tree.KwArgs> {}
+
+	const Tree: TreeConstructor;
+
+	export = Tree;
+}
+
+declare module 'dgrid/extensions/ColumnHider' {
+	import List = require('dgrid/List');
+	import Grid = require('dgrid/Grid');
+
+	interface ColumnHider {
+		columns: { [ key: string ]: ColumnHider.Column };
+
+		column(target: any): ColumnHider.Column;
+		cell(target: Grid.CellArg, columnId?: string): ColumnHider.Cell<any>;
+		left(target: ColumnHider.Cell<any> | Grid.CellArg, steps?: number): ColumnHider.Cell<any>;
+		right(target: ColumnHider.Cell<any> | Grid.CellArg, steps?: number): ColumnHider.Cell<any>;
+
+		toggleColumnHiddenState(id: string, hidden?: boolean): void;
+	}
+
+	module ColumnHider {
+		export interface Cell<T> {
+			row: List.Row<T>;
+			column: Column;
+			element: HTMLElement;
+		}
+		export interface Column extends Grid.Column {
+			hidden?: boolean;
+			unhidable?: boolean;
+		}
+		export type ColumnSpec = { [key: string]: Column | string; } | Column[];
+		export interface KwArgs extends Grid.KwArgs {
+			columns?: ColumnSpec;
+		}
+	}
+
+	interface ColumnHiderConstructor extends dgrid.Constructor<ColumnHider, ColumnHider.KwArgs> {}
+
+	const ColumnHider: ColumnHiderConstructor;
+
+	export = ColumnHider;
+}
+
+declare module 'dgrid/extensions/ColumnReorder' {
+	import List = require('dgrid/List');
+	import Grid = require('dgrid/Grid');
+
+	interface ColumnReorder {
+		columnDndConstructor: Function;
+	}
+
+	module ColumnReorder {
+		export interface ColumnDndSource extends dojo.dnd.Source {}
+		export interface ColumnDndSourceConstructor extends dojo._base.DeclareConstructor<ColumnDndSource> {}
+
+		export interface Cell<T> {
+			row: List.Row<T>;
+			column: Column;
+			element: HTMLElement;
+		}
+		export interface Column extends Grid.Column {
+			reorderable?: boolean;
+		}
+		export type ColumnSpec = { [key: string]: Column | string; } | Column[];
+		export interface KwArgs extends Grid.KwArgs {
+			columnDndConstructor?: Function;
+			columns?: ColumnSpec;
+			subRows?: Array<Column[]>;
+		}
+	}
+
+	interface ColumnReorderConstructor extends dgrid.Constructor<ColumnReorder, ColumnReorder.KwArgs> {
+		ColumnDndSource: ColumnReorder.ColumnDndSourceConstructor;
+	}
+
+	const ColumnReorder: ColumnReorderConstructor;
+
+	export = ColumnReorder;
+}
+
+declare module 'dgrid/extensions/ColumnResizer' {
+	import List = require('dgrid/List');
+	import Grid = require('dgrid/Grid');
+
+	interface ColumnResizer {
+		adjustLastColumn: boolean;
+		minWidth: number;
+
+		resizeColumnWidth(columnId: string, width: number): void;
+	}
+
+	module ColumnResizer {
+		export interface Cell<T> {
+			row: List.Row<T>;
+			column: Column;
+			element: HTMLElement;
+		}
+		export interface Column extends Grid.Column {
+			resizable?: boolean;
+			width?: number;
+		}
+		export type ColumnSpec = { [key: string]: Column | string; } | Column[];
+		export interface KwArgs extends Grid.KwArgs {
+			adjustLastColumn?: boolean;
+			minWidth?: number;
+			columns?: ColumnSpec;
+			subRows?: Array<Column[]>;
+		}
+	}
+	interface ColumnResizerConstructor extends dgrid.Constructor<ColumnResizer, ColumnResizer.KwArgs> {}
+
+	const ColumnResizer: ColumnResizerConstructor;
+
+	export = ColumnResizer;
+}
+
+declare module 'dgrid/extensions/CompoundColumns' {
+	import List = require('dgrid/List');
+	import Grid = require('dgrid/Grid');
+
+	interface CompoundColumns {
+		adjustLastColumn: boolean;
+		minWidth: number;
+
+		resizeColumnWidth(columnId: string, width: number): void;
+	}
+
+	module CompoundColumns {
+		export interface Cell<T> {
+			row: List.Row<T>;
+			column: Column;
+			element: HTMLElement;
+		}
+		export interface Column extends Grid.Column {
+			children?: Column[];
+			showChildHeaders?: boolean;
+		}
+		export type ColumnSpec = { [key: string]: Column | string; } | Column[];
+		export interface KwArgs extends Grid.KwArgs {
+			adjustLastColumn?: boolean;
+			minWidth?: number;
+			columns?: ColumnSpec;
+			subRows?: Array<Column[]>;
+		}
+	}
+
+	interface CompoundColumnsConstructor extends dgrid.Constructor<CompoundColumns, CompoundColumns.KwArgs> {}
+
+	const CompoundColumns: CompoundColumnsConstructor;
+
+	export = CompoundColumns;
+}
+
+declare module 'dgrid/extensions/DijitRegistry' {
+	interface DijitRegistry {
+		minSize: number;
+		maxSize: number;
+		layoutPriority: number;
+		showTitle: boolean;
+
+		buildRendering(): void;
+		destroyRecursive(): void;
+		getChildren(): any[];
+		getParent(): any;
+		isLeftToRight(): boolean;
+		placeAt(reference: any, position?: string | number): any;
+		resize(dim?: dojo.DomGeometryWidthHeight): void;
+		watch(...args: any[]): void;
+	}
+
+	module DijitRegistry {
+		export interface KwArgs {
+			minSize?: number;
+			maxSize?: number;
+			layoutPriority?: number;
+			showTitle?: boolean;
+		}
+	}
+
+	interface DijitRegistryConstructor extends dgrid.Constructor<DijitRegistry, DijitRegistry.KwArgs> {}
+
+	const DijitRegistry: DijitRegistryConstructor;
+
+	export = DijitRegistry;
+}
+
+declare module 'dgrid/extensions/DnD' {
+	import List = require('dgrid/List');
+
+	interface Dnd {
+		dndSourceType: string;
+		dndParams: any;
+		dndConstructor: Function;
+	}
+
+	module Dnd {
+		export interface GridSource extends dojo.dnd.Source {
+			grid: List;
+		}
+		export interface GridSourceConstructor extends dojo._base.DeclareConstructor<GridSource> {}
+
+		export interface KwArgs {
+			dndSourceType?: string;
+			dndParams?: any;
+			dndConstructor?: Function;
+		}
+	}
+
+	interface DndConstructor extends dgrid.Constructor<Dnd, Dnd.KwArgs> {
+		GridSource: Dnd.GridSource;
+	}
+
+	const Dnd: DndConstructor;
+
+	export = Dnd;
+}
+
+declare module 'dgrid/extensions/Pagination' {
+	import StoreMixin = require('dgrid/_StoreMixin');
+
+	interface Pagination extends StoreMixin {
+		rowsPerPage: number;
+		pagingTextBox: boolean;
+		previousNextArrows: boolean;
+		firstLastArrows: boolean;
+		pagingLinks: number;
+		pageSizeOptions: number[];
+		showLoadingMessage: boolean;
+		i18nPagination: any;
+
+		gotoPage(page: number): dojo.promise.Promise<any>;
+	}
+
+	module Pagination {
+		export interface KwArgs extends StoreMixin.KwArgs {
+			rowsPerPage?: number;
+			pagingTextBox?: boolean;
+			previousNextArrows?: boolean;
+			firstLastArrows?: boolean;
+			pagingLinks?: number;
+			pageSizeOptions?: number[];
+			showLoadingMessage?: boolean;
+			i18nPagination?: any;
+		}
+	}
+
+	interface PaginationConstructor extends dgrid.Constructor<Pagination, Pagination.KwArgs> {}
+
+	const Pagination: PaginationConstructor;
+
+	export = Pagination;
+}
+
+declare module 'dgrid/extensions/SingleQuery' {
+	import StoreMixin = require('dgrid/_StoreMixin');
+	export = StoreMixin;
+}
+
+declare module 'dgrid/util/has-css3' {
+	import dojoHas = require('dojo/has');
+	export = dojoHas;
+}
+
+declare module 'dgrid/util/misc' {
+	module util {
+		export let defaultDelay: number;
+		export function throttle<T extends Function>(callback: T, context?: any, delay?: number): T;
+		export function throttleDelayed<T extends Function>(callback: T, context?: any, delay?: number): T;
+		export function debounce<T extends Function>(callback: T, context?: any, delay?: number): T;
+		export function each<T, U>(arrayOrObject: T[], callback: (this: U, item: T, index: number, arrayOrObject: T[]) => void, context: U): void;
+		export function each<T>(arrayOrObject: T[], callback: (item: T, index: number, arrayOrObject: T[]) => void): void;
+		export function each<T>(arrayOrObject: {}, callback: (this: T, item: any, index: number, arrayOrObject: {}) => void, context: T): void;
+		export function each(arrayOrObject: {}, callback: (item: any, index: number, arrayOrObject: {}) => void): void;
+
+		export interface CssRuleHandle extends dojo.Handle {
+			get(prop: string): string;
+			set(prop: string, value: string): void;
+		}
+
+		export function addCssRule(selector: string, css: string): CssRuleHandle;
+		export function escapeCssIdentifier(id: string, replace?: string): void;
+	}
+
+	export = util;
+}
+
+declare module 'dgrid/util/touch' {
+	module touch {
+		export let tapRadius: number;
+		export let dbltapTime: number;
+
+		export function selector(selector: string, type: string | dojo.ExtensionEvent, children?: boolean): dojo.ExtensionEvent;
+		export function countCurrentTouches(event: Event, node: Element): number;
+
+		export function tap(target: Element, listener: dojo.EventListener): dojo.Handle;
+		export function dbltap(target: Element, listener: dojo.EventListener): dojo.Handle;
+	}
+
+	export = touch;
+}
diff --git a/dojo-typings/src/main/typings/dgrid/index.d.ts b/dojo-typings/src/main/typings/dgrid/index.d.ts
new file mode 100644
--- /dev/null
+++ b/dojo-typings/src/main/typings/dgrid/index.d.ts
@@ -0,0 +1,1 @@
+/// <reference path="dgrid.d.ts" />
diff --git a/dojo-typings/src/main/typings/dijit/form.d.ts b/dojo-typings/src/main/typings/dijit/form.d.ts
--- a/dojo-typings/src/main/typings/dijit/form.d.ts
+++ b/dojo-typings/src/main/typings/dijit/form.d.ts
@@ -123,11 +123,11 @@ declare namespace dijit {
 			reset(): void;
 			labelFunc(item: T, store: dojo.store.api.Store<T, Q, O>): string;
 
-			set(name: 'value', value: string): this;
-			set(name: 'item', value: T): this;
-			set(name: 'disabled', value: boolean): this;
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: 'value', value: string): this;
+			// set(name: 'item', value: T): this;
+			// set(name: 'disabled', value: boolean): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		/* dijit/form/_ButtonMixin */
@@ -214,8 +214,8 @@ declare namespace dijit {
 			 */
 			handleKey(evt: KeyboardEvent): boolean;
 
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		interface _ComboBoxMenuConstructor extends _WidgetBaseConstructor<_ComboBoxMenu<any>> {
@@ -271,9 +271,9 @@ declare namespace dijit {
 			selectLastNode(): void;
 			getHighlightedOption(): HTMLElement;
 
-			set(name: 'value', value: Object): this;
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: 'value', value: Object): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		/* dijit/form/_DateTimeTextBox */
@@ -361,15 +361,15 @@ declare namespace dijit {
 			 */
 			_isInvalidDate(value: Date): boolean;
 
-			get(name: 'displayedValue'): string;
-			get(name: string): any;
+			// get(name: 'displayedValue'): string;
+			// get(name: string): any;
 
-			set(name: 'displayedValue', value: string): this;
-			set(name: 'dropDownDefaultValue', value: Date): this;
-			set(name: 'value', value: Date | string): this;
-			set(name: 'constraints', value: DateTimeConstraints): this;
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: 'displayedValue', value: string): this;
+			// set(name: 'dropDownDefaultValue', value: Date): this;
+			// set(name: 'value', value: Date | string): this;
+			// set(name: 'constraints', value: DateTimeConstraints): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		interface _DateTimeTextBoxConstructor<T extends _WidgetBase> extends _WidgetBaseConstructor<_DateTimeTextBox<T>> { }
@@ -707,8 +707,8 @@ declare namespace dijit {
 			 */
 			_layoutHackIE7(): void;
 
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		interface _FormValueWidgetConstructor extends _WidgetBaseConstructor<_FormValueWidget> { }
@@ -720,9 +720,9 @@ declare namespace dijit {
 			setValue(value: string): void;
 			postMixInProperties(): void;
 
-			set(name: 'value', value: string): this;
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: 'value', value: string): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		interface _FormWidgetConstructor extends _WidgetBaseConstructor<_FormWidget> { }
@@ -803,9 +803,9 @@ declare namespace dijit {
 
 			destroy(preserveDom?: boolean): void;
 
-			set(name: 'disabled', value: boolean): this;
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: 'disabled', value: boolean): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		/* dijit/form/_ListBase */
@@ -839,9 +839,9 @@ declare namespace dijit {
 			 */
 			selectPreviousNode(): void;
 
-			set(name: 'selected', value: HTMLElement): this;
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: 'selected', value: HTMLElement): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		/* dijit/form/_ListMouseMixin */
@@ -950,9 +950,9 @@ declare namespace dijit {
 
 			postMixInProperties(): void;
 
-			set(name: 'list', value: string): this;
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: 'list', value: string): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		/* dijit/form/_Spinner */
@@ -1136,12 +1136,12 @@ declare namespace dijit {
 
 			onClick(e: MouseEvent): boolean | void;
 
-			set(name: 'showLabel', value: boolean): this;
-			set(name: 'value', value: string): this;
-			set(name: 'name', value: string): this;
-			set(name: 'label', value: string): this;
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: 'showLabel', value: boolean): this;
+			// set(name: 'value', value: string): this;
+			// set(name: 'name', value: string): this;
+			// set(name: 'label', value: string): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		interface ButtonConstructor extends _WidgetBaseConstructor<Button> { }
@@ -1154,9 +1154,9 @@ declare namespace dijit {
 			postMixInProperties(): void;
 			value: string;
 
-			set(name: 'value', value: string | boolean): this;
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: 'value', value: string | boolean): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		interface CheckBoxConstructor extends _WidgetBaseConstructor<CheckBox> { }
@@ -1164,8 +1164,8 @@ declare namespace dijit {
 		/* dijit/form/ComboBox */
 
 		interface ComboBox<T extends Object, Q extends dojo.store.api.BaseQueryType, O extends dojo.store.api.QueryOptions, C extends Constraints> extends ValidationTextBox<C>, ComboBoxMixin<T, Q, O> {
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		interface ComboBoxConstructor extends _WidgetBaseConstructor<ComboBox<any, any, any, any>> {
@@ -1327,10 +1327,10 @@ declare namespace dijit {
 			_openResultList(results: T[], query: Q, options: O): void;
 			undo(): void;
 
-			set(name: 'displayedValue', value: string): this;
-			set(name: 'item', value: T): this;
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: 'displayedValue', value: string): this;
+			// set(name: 'item', value: T): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		interface FilteringSelectConstructor extends _WidgetBaseConstructor<FilteringSelect<any, any, any, any>> {
@@ -1807,15 +1807,15 @@ declare namespace dijit {
 		/* dijit/form/TextBox */
 
 		interface TextBox extends _FormValueWidget, _TextBoxMixin<Constraints> {
-			set(name: 'displayedValue', value: string): this;
-			set(name: 'disabled', value: boolean): this;
-			set(name: 'value', value: string): this;
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: 'displayedValue', value: string): this;
+			// set(name: 'disabled', value: boolean): this;
+			// set(name: 'value', value: string): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 
-			get(name: 'displayedValue'): string;
-			get(name: 'value'): string;
-			get(name: string): any;
+			// get(name: 'displayedValue'): string;
+			// get(name: 'value'): string;
+			// get(name: string): any;
 		}
 
 		interface TextBoxConstructor extends _WidgetBaseConstructor<TextBox> { }
@@ -1827,9 +1827,9 @@ declare namespace dijit {
 
 			setChecked(checked: boolean): void;
 
-			set(name: 'checked', value: boolean): this;
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: 'checked', value: boolean): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 		}
 
 		interface ToggleButtonConstructor extends _WidgetBaseConstructor<ToggleButton> { }
@@ -1867,19 +1867,19 @@ declare namespace dijit {
 
 			destroy(preserveDom?: boolean): void;
 
-			set(name: 'constraints', value: Constraints): this;
-			set(name: 'disabled', value: boolean): this;
-			set(name: 'message', value: string): this;
-			set(name: 'pattern', value: string | ConstraintsToRegExpString<C>): this;
-			set(name: 'regExp', value: string): this;
-			set(name: 'regExpGen', value: Constraints): this;
-			set(name: 'required', value: boolean): this;
-			set(name: 'value', value: string): this;
-			set(name: string, value: any): this;
-			set(values: Object): this;
+			// set(name: 'constraints', value: Constraints): this;
+			// set(name: 'disabled', value: boolean): this;
+			// set(name: 'message', value: string): this;
+			// set(name: 'pattern', value: string | ConstraintsToRegExpString<C>): this;
+			// set(name: 'regExp', value: string): this;
+			// set(name: 'regExpGen', value: Constraints): this;
+			// set(name: 'required', value: boolean): this;
+			// set(name: 'value', value: string): this;
+			// set(name: string, value: any): this;
+			// set(values: Object): this;
 
-			get(name: 'pattern'): string | ConstraintsToRegExpString<C>;
-			get(name: string): any;
+			// get(name: 'pattern'): string | ConstraintsToRegExpString<C>;
+			// get(name: string): any;
 		}
 
 		interface ValidationTextBoxConstructor extends _WidgetBaseConstructor<ValidationTextBox<Constraints>> {
diff --git a/dojo-typings/src/main/typings/dstore/dstore.d.ts b/dojo-typings/src/main/typings/dstore/dstore.d.ts
new file mode 100644
--- /dev/null
+++ b/dojo-typings/src/main/typings/dstore/dstore.d.ts
@@ -0,0 +1,312 @@
+/// <reference path="../dojo/index.d.ts" />
+
+declare module dstore {
+	export interface FetchArray<T> extends Array<T> {
+		totalLength: number;
+	}
+
+	export interface FetchPromise<T> extends dojo.promise.Promise<T> {
+		totalLength: dojo.promise.Promise<number>;
+	}
+
+	export interface ChangeEvent<T> {
+		id: any;
+		index?: number;
+		previousIndex?: number;
+		target: T;
+		totalLength: number;
+		type: string;
+	}
+
+	export interface Collection<T> {
+		idProperty: string;
+		Model: { new (...args: any[]): T; };
+		tracking?: { remove(): void; };
+
+		add(object: T, options?: {}): dojo.promise.Promise<T>;
+		emit(eventName: string, event: ChangeEvent<T>): boolean;
+		fetch(): dstore.FetchPromise<T[]>;
+		fetchRange(kwArgs: { start?: number; end?: number; }): dstore.FetchPromise<T[]>;
+		filter(query: string | {} | { (item: T, index: number): boolean; }): this;
+		forEach(callback: (item: T, index: number) => void, thisObject?: any): dojo.promise.Promise<T[]>;
+		get(id: any): dojo.promise.Promise<T>;
+		getIdentity(object: T): any;
+		on(eventName: string, listener: (event: ChangeEvent<T>) => void): dojo.Handle;
+		put(object: T, options?: {}): dojo.promise.Promise<T>;
+		remove(id: any): dojo.promise.Promise<Object>;
+		sort(property: string | { (a: T, b: T): number; }, descending?: boolean): this;
+		track?(): this;
+	}
+
+	export interface SyncCollection<T> extends Collection<T> {
+		addSync(object: T, options?: {}): T;
+		fetchSync(): dstore.FetchArray<T>;
+		fetchRangeSync(kwArgs: { start?: number; end?: number; }): dstore.FetchArray<T>;
+		filter(query: string | {} | { (item: T, index: number): boolean; }): this;
+		getSync(id: any): T;
+		putSync(object: T, options?: {}): T;
+		removeSync(id: any): boolean;
+		sort(property: string | { (a: T, b: T): number; }, descending?: boolean): this;
+		track?(): this;
+	}
+}
+
+declare module 'dstore/Cache' {
+	import Store = require('dstore/Store');
+
+	interface Cache<T> extends Store<T> {
+		cachingStore: dstore.Collection<T>;
+		evict(id: any): void;
+	}
+
+	module Cache {
+		export interface Constructor extends dojo._base.DeclareConstructor<Cache<any>> {
+			new <T>(kwArgs?: Cache.KwArgs<T>): Cache<T>;
+		}
+
+		export interface KwArgs<T> extends Store.KwArgs {
+			cachingStore?: dstore.Collection<T>;
+		}
+	}
+
+	const Cache: Cache.Constructor;
+
+	export = Cache;
+}
+
+declare module 'dstore/legacy/DstoreAdapter' {
+	import Store = require('dstore/Store');
+
+	interface DstoreAdapter<T> {
+		constructor(collection: dstore.Collection<T>): DstoreAdapter<T>;
+		get(id: any): any;
+		put(object: T, options?: {}): any;
+		remove(id: any): any;
+		query(query: any, options?: {}): any;
+	}
+
+	module DstoreAdapter {
+		export interface Constructor extends dojo._base.DeclareConstructor<DstoreAdapter<any>> {
+			new <T>(store: Store<T>): DstoreAdapter<Store<T>>;
+		}
+	}
+
+	const DstoreAdapter: DstoreAdapter.Constructor;
+	export = DstoreAdapter;
+}
+
+declare module 'dstore/Memory' {
+	import Store = require('dstore/Store');
+
+	interface Memory<T> extends Store<T>, dstore.SyncCollection<T> {
+		data: T[];
+
+		addSync(object: T, options?: {}): T;
+		fetchSync(): dstore.FetchArray<T>;
+		fetchRangeSync(kwArgs: { start?: number; end?: number; }): dstore.FetchArray<T>;
+		filter(query: string | {} | { (item: T, index: number): boolean; }): this;
+		getSync(id: any): T;
+		putSync(object: T, options?: {}): T;
+		removeSync(id: any): boolean;
+		setData(data: T[]): void;
+		sort(property: string | { (a: T, b: T): number; }, descending?: boolean): this;
+		track(): this;
+		remove(id: any): dojo.promise.Promise<{}>;
+	}
+
+	module Memory {
+		export interface Constructor extends dojo._base.DeclareConstructor<Memory<any>> {
+			new <T>(kwArgs?: Memory.KwArgs<T>): Memory<T>;
+		}
+
+		export interface KwArgs<T> extends Store.KwArgs {
+			data?: T[];
+		}
+	}
+
+	const Memory: Memory.Constructor;
+
+	export = Memory;
+}
+
+declare module 'dstore/Trackable' {
+	interface Trackable<T> {
+		currentRange: any[];
+		track(): this;
+	}
+
+	module Trackable {
+		export interface Constructor extends dojo._base.DeclareConstructor<Trackable<any>> {
+			new <T>(...args: any[]): Trackable<T>;
+		}
+	}
+
+	const Trackable: Trackable.Constructor;
+
+	export = Trackable;
+}
+
+declare module 'dstore/Tree' {
+	interface Tree<T> {
+		mayHaveChildren(object: T): boolean;
+		getRootCollection(): dstore.Collection<T>;
+		getChildren(object: T): dstore.Collection<T>;
+	}
+
+	module Tree {
+		export interface Constructor extends dojo._base.DeclareConstructor<Tree<any>> {
+			new <T>(...args: any[]): Tree<T>;
+		}
+	}
+
+	const Tree: Tree.Constructor;
+
+	export = Tree;
+}
+
+declare module 'dstore/Promised' {
+	import * as Promise from 'dojo/promise/Promise';
+
+	interface Promised<T> {
+		get(id: any): Promise<T>;
+		put(object: T, options?: {}): Promise<T>;
+		add(object: T, options?: {}): Promise<T>;
+		remove(id: any): Promise<boolean>;
+		fetch(): dstore.FetchPromise<T>;
+		fetchRange(args: { start?: number; end?: number; }): dstore.FetchPromise<T>;
+	}
+
+	module Promised {
+		export interface Constructor extends dojo._base.DeclareConstructor<Promised<any>> {
+			new <T>(...args: any[]): Promised<T>;
+		}
+	}
+
+	const Promised: Promised.Constructor;
+
+	export = Promised;
+}
+
+declare module 'dstore/SimpleQuery' {
+	interface SimpleQuery<T> {
+	}
+
+	module SimpleQuery {
+		export interface Constructor extends dojo._base.DeclareConstructor<SimpleQuery<any>> {
+			new <T>(...args: any[]): SimpleQuery<T>;
+		}
+	}
+
+	const SimpleQuery: SimpleQuery.Constructor;
+
+	export = SimpleQuery;
+}
+
+declare module 'dstore/Request' {
+	import Store = require('dstore/Store');
+
+	interface Request<T> extends Store<T> {
+		headers: {};
+		parse: (serializedObject: string) => {};
+		target: string;
+		ascendingPrefix: string;
+		descendingPrefix: string;
+		accepts: string;
+
+		track(): this;
+	}
+
+	module Request {
+		export interface Constructor extends dojo._base.DeclareConstructor<Request<any>> {
+			new <T>(kwArgs?: Request.KwArgs): Request<T>;
+		}
+		export interface KwArgs extends Store.KwArgs {
+			headers?: typeof Request.prototype.headers;
+			parse?: typeof Request.prototype.parse;
+			target?: typeof Request.prototype.target;
+			ascendingPrefix?: typeof Request.prototype.ascendingPrefix;
+			descendingPrefix?: typeof Request.prototype.descendingPrefix;
+			accepts?: typeof Request.prototype.accepts;
+		}
+	}
+
+	const Request: Request.Constructor;
+
+	export = Request;
+}
+
+declare module 'dstore/RequestMemory' {
+	import Request = require('dstore/Request');
+	import Cache = require('dstore/Cache');
+
+	interface RequestMemory<T> extends Request<T>, Cache<T> {
+		cachingStore: dstore.Collection<T>;
+		evict(id: any): void;
+
+		track(): this;
+	}
+
+	module RequestMemory {
+		export interface Constructor extends dojo._base.DeclareConstructor<RequestMemory<any>> {
+			new <T>(kwArgs?: RequestMemory.KwArgs<T>): RequestMemory<T>;
+		}
+
+		export interface KwArgs<T> extends Request.KwArgs, Cache.KwArgs<T> {}
+	}
+
+	const RequestMemory: RequestMemory.Constructor;
+
+	export = RequestMemory;
+}
+
+declare module 'dstore/Rest' {
+	import Request = require('dstore/Request');
+
+	interface Rest<T> extends Request<T> {}
+
+	module Rest {
+		export interface Constructor extends dojo._base.DeclareConstructor<Rest<any>> {
+			new <T>(kwArgs?: Request.KwArgs): Rest<T>;
+		}
+	}
+
+	const Rest: Rest.Constructor;
+
+	export = Rest;
+}
+
+declare module 'dstore/Store' {
+	interface Store<T> extends dstore.Collection<T> {
+		idProperty: string;
+		Model: { new (...args: any[]): T; };
+		total: dojo.promise.Promise<number>;
+
+		add(object: T, options?: {}): dojo.promise.Promise<T>;
+		emit(eventName: string, event: dstore.ChangeEvent<T>): boolean;
+		fetch(): dstore.FetchPromise<T[]>;
+		fetchRange(kwArgs: { start?: number; end?: number; }): dstore.FetchPromise<T[]>;
+		filter(query: string | {} | { (item: T, index: number): boolean; }): this;
+		forEach(callback: (item: T, index: number) => void, thisObject?: any): dojo.promise.Promise<T[]>;
+		get(id: any): dojo.promise.Promise<T>;
+		getIdentity(object: T): any;
+		on(eventName: string, listener: (event: dstore.ChangeEvent<T>) => void): dojo.Handle;
+		put(object: T, options?: {}): dojo.promise.Promise<T>;
+		remove(id: any): dojo.promise.Promise<{}>;
+		sort(property: string | { (a: T, b: T): number; }, descending?: boolean): this;
+	}
+
+	module Store {
+		export interface Constructor extends dojo._base.DeclareConstructor<Store<any>> {
+			new <T>(kwArgs?: Store.KwArgs): Store<T>;
+		}
+
+		export interface KwArgs {
+			idProperty?: typeof Store.prototype.idProperty;
+			Model?: typeof Store.prototype.Model;
+		}
+	}
+
+	const Store: Store.Constructor;
+
+	export = Store;
+}
diff --git a/dojo-typings/src/main/typings/dstore/index.d.ts b/dojo-typings/src/main/typings/dstore/index.d.ts
new file mode 100644
--- /dev/null
+++ b/dojo-typings/src/main/typings/dstore/index.d.ts
@@ -0,0 +1,1 @@
+/// <reference path="dstore.d.ts" />
diff --git a/dojo-typings/src/main/typings/index.d.ts b/dojo-typings/src/main/typings/index.d.ts
new file mode 100644
--- /dev/null
+++ b/dojo-typings/src/main/typings/index.d.ts
@@ -0,0 +1,3 @@
+/// <reference path="dojo/modules.d.ts" />
+/// <reference path="dijit/modules.d.ts" />
+
diff --git a/dojo-typings/src/test/tsconfig.json b/dojo-typings/src/test/tsconfig.json
--- a/dojo-typings/src/test/tsconfig.json
+++ b/dojo-typings/src/test/tsconfig.json
@@ -10,8 +10,7 @@
         ],
         "types": [
             "requirejs",
-            "../main/typings/dojo/modules",
-            "../main/typings/dijit/modules"
+            "../main/typings"
         ],
         "module": "ESNext",
         "target": "ESNext"