/// <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;
}