declare namespace dojo {
	namespace dnd {

		/* implied types */

		interface DndLocation {
			t: number;
			l: number;
		}

		/* dojo/dnd/autoscroll */

		interface AutoScroll {
			getViewport(doc?: Document): DomGeometryBox;
			V_TRIGGER_AUTOSCROLL: number;
			H_TRIGGER_AUTOSCROLL: number;
			V_AUTOSCROLL_VALUE: number;
			H_AUTOSCROLL_VALUE: number;

			/**
			 * Called at the start of a drag.
			 */
			autoScrollStart(d: Document): void;

			/**
			 * a handler for mousemove and touchmove events, which scrolls the window, if
			 * necessary
			 */
			autoScroll(e: Event): void;

			_validNodes: { div: number; p: number; td: number; };
			_validOverflow: { auto: number; scroll: number; };

			/**
			 * a handler for mousemove and touchmove events, which scrolls the first available
			 * Dom element, it falls back to exports.autoScroll()
			 */
			autoScrollNodes(e: Event): void;
		}

		/* dojo/dnd/AutoSource */

		interface AutoSource extends Source { }

		interface AutoSourceConstructor {
			new (node: NodeOrString, params?: SourceArgs): AutoSource;
			prototype: AutoSource;
		}

		/* dojo/dnd/Avatar */

		interface Avatar {

			/**
			 * constructor function;
			 * it is separate so it can be (dynamically) overwritten in case of need
			 */
			construct(): void;

			/**
			 * destructor for the avatar; called to remove all references so it can be garbage-collected
			 */
			destroy(): void;

			/**
			 * updates the avatar to reflect the current DnD state
			 */
			update(): void;

			/**
			 * generates a proper text to reflect copying or moving of items
			 */
			_generateText(): string;

		}

		interface AvatarConstructor {
			new (manager: Manager): Avatar;
			prototype: Avatar;
		}

		/* dojo/dnd/common */

		interface Common {

			getCopyKeyState(evt: Event): boolean;

			_uniqueId: number;

			/**
			 * returns a unique string for use with any DOM element
			 */
			getUniqueId(): number;

			_empty: { };

			/**
			 * returns true if user clicked on a form element
			 */
			isFormElement(e: Event): boolean;
		}

		/* dojo/dnd/Container */

		interface ContainerItem<T extends GenericObject> {
			type?: string[];
			data?: T;
		}

		interface ContainerArgs {

			/**
			 * a creator function, which takes a data item, and returns an object like that:
			 * {node: newNode, data: usedData, type: arrayOfStrings}
			 */
			creator<T>(data?: ContainerItem<T>): { node: Element; data: T; type: string[]; };

			/**
			 * don't start the drag operation, if clicked on form elements
			 */
			skipForm: boolean;

			/**
			 * node or node's id to use as the parent node for dropped items
			 * (must be underneath the 'node' parameter in the DOM)
			 */
			dropParent: NodeOrString;

			/**
			 * skip startup(), which collects children, for deferred initialization
			 * (this is used in the markup mode)
			 */
			_skipStartup: boolean;
		}

		interface Container extends Evented {

			/**
			 * Indicates whether to allow dnd item nodes to be nested within other elements.
			 * By default this is false, indicating that only direct children of the container can
			 * be draggable dnd item nodes
			 */
			skipForm: boolean;

			/**
			 * Indicates whether to allow dnd item nodes to be nested within other elements.
			 * By default this is false, indicating that only direct children of the container can
			 * be draggable dnd item nodes
			 */
			allowNested: boolean;

			/**
			 * The DOM node the mouse is currently hovered over
			 */
			current: HTMLElement;

			/**
			 * Map from an item's id (which is also the DOMNode's id) to
			 * the dojo/dnd/Container.Item itself.
			 */
			map: { [name: string]: ContainerItem<any> };

			/**
			 * creator function, dummy at the moment
			 */
			creator<T>(data?: ContainerItem<T>): { node: Element; data: T; type: string[]; };

			/**
			 * returns a data item by its key (id)
			 */
			getItem<T>(key: string): ContainerItem<T>;

			/**
			 * associates a data item with its key (id)
			 */
			setITem<T>(key: string, data: ContainerItem<T>): void;

			/**
			 * removes a data item from the map by its key (id)
			 */
			delItem(key: string): void;

			/**
			 * iterates over a data map skipping members that
			 * are present in the empty object (IE and/or 3rd-party libraries).
			 */
			forInItems<T, U>(f: (i: ContainerItem<T>, idx?: number, container?: Container) => void, o?: U): U;

			/**
			 * removes all data items from the map
			 */
			clearItems(): void;

			/**
			 * returns a list (an array) of all valid child nodes
			 */
			getAllNodes(): NodeList<Node>;

			/**
			 * sync up the node list with the data map
			 */
			sync(): this;

			/**
			 * inserts an array of new nodes before/after an anchor node
			 */
			insertNodes(data: ContainerItem<any>[], before?: boolean, anchor?: Element): this;

			/**
			 * prepares this object to be garbage-collected
			 */
			destroy(): void;

			markupFactory<T>(params: ContainerArgs, node: Element, Ctor: GenericConstructor<T>): T;

			/**
			 * collects valid child items and populate the map
			 */
			startup(): void;

			/**
			 * event processor for onmouseover or touch, to mark that element as the current element
			 */
			onMouseOver(e: Event): void;

			/**
			 * event processor for onmouseout
			 */
			onMouseOut(e: Event): void;

			/**
			 * event processor for onselectevent and ondragevent
			 */
			onSelectStart(e: Event): void;

			/**
			 * this function is called once, when mouse is over our container
			 */
			onOverEvent(e: Event): void;

			/**
			 * this function is called once, when mouse is out of our container
			 */
			onOutEvent(e: Event): void;

			/**
			 * changes a named state to new state value
			 */
			_changeState(type: string, newState: string): void;

			/**
			 * adds a class with prefix "dojoDndItem"
			 */
			_addItemClass(node: Element, type: string): void;

			/**
			 * removes a class with prefix "dojoDndItem"
			 */
			_removeItemClass(node: Element, type: string): void;

			/**
			 * gets a child, which is under the mouse at the moment, or null
			 */
			_getChildByEvent(e: Event): void;

			/**
			 * adds all necessary data to the output of the user-supplied creator function
			 */
			_normalizedCreator<T>(item: ContainerItem<T>, hint: string): this;
		}

		interface ContainerConstructor {
			/**
			 * a constructor of the Container
			 */
			new (node: NodeOrString, params?: ContainerArgs): Container;
			prototype: Container;
		}

		interface Common {

			/**
			 * returns a function, which creates an element of given tag
			 * (SPAN by default) and sets its innerHTML to given text
			 */
			_createNode(tag: string): (text: string) => HTMLElement;

			/**
			 * creates a TR/TD structure with given text as an innerHTML of TD
			 */
			_createTrTd(text: string): HTMLTableRowElement;

			/**
			 * creates a SPAN element with given text as its innerHTML
			 */
			_createSpan(text: string): HTMLSpanElement;

			/**
			 * a dictionary that maps container tag names to child tag names
			 */
			_defaultCreatorNodes: { ul: string, ol: string, div: string, p: string };

			/**
			 * takes a parent node, and returns an appropriate creator function
			 */
			_defaultCreator<T>(node: HTMLElement): { node: HTMLElement; data: T; type: string };
		}

		/* dojo/dnd/Manager */

		interface Manager extends Evented {
			OFFSET_X: number;
			OFFSET_Y: number;

			overSource(source: Source): void;
			outSource(source: Source): void;
			startDrag(source: Source, nodes: HTMLElement[], copy?: boolean): void;
			canDrop(flag: boolean): void;
			stopDrag(): void;
			makeAvatar(): Avatar;
			updateAvatar(): void;
			onMouseMove(e: MouseEvent): void;
			onMouseUp(e: MouseEvent): void;
			onKeyDown(e: KeyboardEvent): void;
			onKeyUp(e: KeyboardEvent): void;
			_setCopyStatus(copy?: boolean): void;
		}

		interface ManagerConstructor {
			/**
			 * the manager of DnD operations (usually a singleton)
			 */
			new (): Manager;
			prototype: Manager;

			/**
			 * Returns the current DnD manager.  Creates one if it is not created yet.
			 */
			manager(): Manager;
		}

		interface Common {
			_manager: Manager;
		}

		/* dojo/dnd/move */

		interface Move {
			constrainedMoveable: ConstrainedMoveableConstructor;
			boxConstrainedMoveable: BoxConstrainedMoveableConstructor;
			parentConstrainedMoveable: ParentConstrainedMoveableConstructor;
		}

		interface ConstrainedMoveableArgs extends MoveableArgs {
			/**
			 * Calculates a constraint box.
			 * It is called in a context of the moveable object.
			 */
			constraints?: () => DomGeometryBox;

			/**
			 * restrict move within boundaries.
			 */
			within?: boolean;
		}

		interface ConstrainedMoveable extends Moveable {
			/**
			 * Calculates a constraint box.
			 * It is called in a context of the moveable object.
			 */
			constraints: () => DomGeometryBox;

			/**
			 * restrict move within boundaries.
			 */
			within: boolean;
		}

		interface ConstrainedMoveableConstructor {
			/**
			 * an object that makes a node moveable
			 */
			new (node: NodeOrString, params?: ConstrainedMoveableArgs): ConstrainedMoveable;
		}

		interface BoxConstrainedMoveableArgs extends ConstrainedMoveableArgs {
			/**
			 * a constraint box
			 */
			box?: DomGeometryBox;
		}

		interface BoxConstrainedMoveable extends ConstrainedMoveable {
			/**
			 * a constraint box
			 */
			box: DomGeometryBox;
		}

		interface BoxConstrainedMoveableConstructor {
			/**
			 * an object, which makes a node moveable
			 */
			new (node: NodeOrString, params?: BoxConstrainedMoveableArgs): BoxConstrainedMoveable;
		}

		type ConstraintArea = 'border' |  'content' | 'margin' | 'padding';

		interface ParentConstrainedMoveableArgs extends ConstrainedMoveableArgs {
			/**
			 * A parent's area to restrict the move.
			 * Can be "margin", "border", "padding", or "content".
			 */
			area?: ConstraintArea;
		}

		interface ParentConstrainedMoveable extends ConstrainedMoveable {
			/**
			 * A parent's area to restrict the move.
			 * Can be "margin", "border", "padding", or "content".
			 */
			area: ConstraintArea;
		}

		interface ParentConstrainedMoveableConstructor {
			/**
			 * an object, which makes a node moveable
			 */
			new (node: NodeOrString, params?: ParentConstrainedMoveableArgs): ParentConstrainedMoveable;
		}

		/* dojo/dnd/Moveable */

		interface MoveableArgs {
			/**
			 * A node (or node's id), which is used as a mouse handle.
			 * If omitted, the node itself is used as a handle.
			 */
			handle?: NodeOrString;

			/**
			 * delay move by this number of pixels
			 */
			delay?: number;

			/**
			 * skip move of form elements
			 */
			skip?: boolean;

			/**
			 * a constructor of custom Mover
			 */
			mover?: MoverConstructor;
		}

		interface Moveable {
			/**
			 * markup methods
			 */
			markupFactory<T>(params: MoveableArgs, node: HTMLElement, Ctor: GenericConstructor<T>): T;

			/**
			 * stops watching for possible move, deletes all references, so the object can be garbage-collected
			 */
			destroy(): void;

			/**
			 * event processor for onmousedown/ontouchstart, creates a Mover for the node
			 */
			onMouseDown(e: MouseEvent): void;

			/**
			 * event processor for onmousemove/ontouchmove, used only for delayed drags
			 */
			onMouseMove(e: MouseEvent): void;

			/**
			 * event processor for onmouseup, used only for delayed drags
			 */
			onMouseUp(e: MouseEvent): void;

			/**
			 * called when the drag is detected;
			 * responsible for creation of the mover
			 */
			onDragDetected(e: Event): void;

			/**
			 * called before every move operation
			 */
			onMoveStart(mover: Mover): void;

			/**
			 * called after every move operation
			 */
			onMoveStop(mover: Mover): void;

			/**
			 * called during the very first move notification;
			 * can be used to initialize coordinates, can be overwritten.
			 */
			onFirstMove(mover: Mover, e: Event): void;

			/**
			 * called during every move notification;
			 * should actually move the node; can be overwritten.
			 */
			onMove(mover: Mover, leftTop: DndLocation, e?: Event): void;

			/**
			 * called before every incremental move; can be overwritten.
			 */
			onMoving(mover: Mover, leftTop: DndLocation): void;

			/**
			 * called after every incremental move; can be overwritten.
			 */
			onMoved(mover: Mover, leftTop: DndLocation): void;
		}

		interface MoveableConstructor {
			new (node: NodeOrString, params?: MoveableArgs): Moveable;
			prototype: Moveable;
		}

		/* dojo/dnd/Mover */

		interface MoverHost extends GenericObject {
			onMoveStart(mover: Mover): void;
			onMoveStop(mover: Mover): void;
		}

		interface Mover extends Evented {
			/**
			 * event processor for onmousemove/ontouchmove
			 */
			onMouseMove(e: MouseEvent): void;

			onMouseUp(e: MouseEvent): void;

			/**
			 * makes the node absolute; it is meant to be called only once.
			 * relative and absolutely positioned nodes are assumed to use pixel units
			 */
			onFirstMove(e: Event): void;

			/**
			 * stops the move, deletes all references, so the object can be garbage-collected
			 */
			destroy(): void;
		}

		interface MoverConstructor {
			/**
			 * an object which makes a node follow the mouse, or touch-drag on touch devices.
			 * Used as a default mover, and as a base class for custom movers.
			 */
			new (node: HTMLElement, e: MouseEvent, host: MoverHost): Mover;
			prototype: Mover;
		}

		/* dojo/dnd/Selector */

		interface Selector extends Container {

			/**
			 * The set of id's that are currently selected, such that this.selection[id] == 1
			 * if the node w/that id is selected.  Can iterate over selected node's id's like:
			 *     for(var id in this.selection)
			 */
			selection: { [id: string]: number };

			/**
			 * is singular property
			 */
			singular: boolean;

			/**
			 * returns a list (an array) of selected nodes
			 */
			getSelectedNodes(): NodeList<Node>;

			/**
			 * unselects all items
			 */
			selectNone(): this;

			/**
			 * selects all items
			 */
			selectAll(): this;

			/**
			 * deletes all selected items
			 */
			deleteSelectedNodes(): this;

			/**
			 * iterates over selected items;
			 * see `dojo/dnd/Container.forInItems()` for details
			 */
			forInSelectedItems<T>(f: (i: ContainerItem<T>, idx?: number, container?: Container) => void, o?: GenericObject): void;

			/**
			 * event processor for onmousemove
			 */
			onMouseMove(e: Event): void;

			/**
			 * this function is called once, when mouse is over our container
			 */
			onOverEvent(): void;

			/**
			 * this function is called once, when mouse is out of our container
			 */
			onOutEvent(): void;

			/**
			 * unselects all items
			 */
			_removeSelection(): this;

			_removeAnchor(): this;
		}

		interface SelectorConstructor {
			/**
			 * constructor of the Selector
			 */
			new (node: NodeOrString, params?: ContainerArgs): Selector;
			prototype: Selector;
		}

		/* dojo/dnd/Source */

		/**
		 * a dict of parameters for DnD Source configuration. Note that any
		 * property on Source elements may be configured, but this is the
		 * short-list
		 */
		interface SourceArgs {
			[arg: string]: any;

			/**
			 * can be used as a DnD source. Defaults to true.
			 */
			isSource?: boolean;

			/**
			 * list of accepted types (text strings) for a target; defaults to
			 * ["text"]
			 */
			accept?: string[];

			/**
			 * if true refreshes the node list on every operation; false by default
			 */
			autoSync?: boolean;

			/**
			 * copy items, if true, use a state of Ctrl key otherwisto
			 * see selfCopy and selfAccept for more details
			 */
			copyOnly?: boolean;

			/**
			 * the move delay in pixels before detecting a drag; 0 by default
			 */
			delay?: number;

			/**
			 * a horizontal container, if true, vertical otherwise or when omitted
			 */
			horizontal?: boolean;

			/**
			 * copy items by default when dropping on itself,
			 * false by default, works only if copyOnly is true
			 */
			selfCopy?: boolean;

			/**
			 * accept its own items when copyOnly is true,
			 * true by default, works only if copyOnly is true
			 */
			selfAccept?: boolean;

			/**
			 * allows dragging only by handles, false by default
			 */
			withHandles?: boolean;

			/**
			 * generate text node for drag and drop, true by default
			 */
			generateText?: boolean;
		}

		interface Source extends Selector {

			/**
			 * checks if the target can accept nodes from this source
			 */
			checkAcceptance(source: Container, nodes: HTMLElement[]): boolean;

			/**
			 * Returns true if we need to copy items, false to move.
			 * It is separated to be overwritten dynamically, if needed.
			 */
			copyState(keyPressed: boolean, self?: boolean): boolean;

			/**
			 * topic event processor for /dnd/source/over, called when detected a current source
			 */
			onDndSourceOver(source: Container): void;

			/**
			 * topic event processor for /dnd/start, called to initiate the DnD operation
			 */
			onDndStart(source: Container, nodes: HTMLElement[], copy?: boolean): void;

			/**
			 * topic event processor for /dnd/drop, called to finish the DnD operation
			 */
			onDndDrop(source: Container, nodes: HTMLElement[], copy: boolean, target: Container): void;

			/**
			 * topic event processor for /dnd/cancel, called to cancel the DnD operation
			 */
			onDndCancel(): void;

			/**
			 * called only on the current target, when drop is performed
			 */
			onDrop(source: Container, nodes: HTMLElement[], copy?: boolean): void;

			/**
			 * called only on the current target, when drop is performed
			 * from an external source
			 */
			onDropExternal(source: Container, nodes: HTMLElement[], copy?: boolean): void;

			/**
			 * called only on the current target, when drop is performed
			 * from the same target/source
			 */
			onDropInternal(nodes: HTMLElement[], copy?: boolean): void;

			/**
			 * called during the active DnD operation, when items
			 * are dragged over this target, and it is not disabled
			 */
			onDraggingOver(): void;

			/**
			 * called during the active DnD operation, when items
			 * are dragged away from this target, and it is not disabled
			 */
			onDraggingOut(): void;

			/**
			 * this function is called once, when mouse is over our container
			 */
			onOverEvent(): void;

			/**
			 * this function is called once, when mouse is out of our container
			 */
			onOutEvent(): void;

			/**
			 * assigns a class to the current target anchor based on "before" status
			 */
			_markTargetAnchor(before?: boolean): void;

			/**
			 * removes a class of the current target anchor based on "before" status
			 */
			_unmarkTargetAnchor(): void;

			/**
			 * changes source's state based on "copy" status
			 */
			_markDndStatus(copy?: boolean): void;

			/**
			 * checks if user clicked on "approved" items
			 */
			_legalMouseDown(e?: Event): boolean;
		}

		interface SourceConstructor {
			new (node: NodeOrString, params?: SourceArgs): Source;
			prototype: Source;
		}

		/* dojo/dnd/Target */

		interface Target extends Source { }

		interface TargetConstructor {
			new (node: HTMLElement, params: SourceArgs): Target;
			prototype: Target;
		}

		/* dojo/dnd/TimedMoveable */

		interface TimedMoveableArgs extends MoveableArgs {
			timeout?: number;
		}

		interface TimedMoveable extends Moveable {
			onMoveStop(mover: Mover): void;
			onMove(mover: Mover, leftTop: DndLocation): void;
		}

		interface TimedMoveableConstructor {
			new (node: HTMLElement, params?: TimedMoveableArgs): TimedMoveable;
			prototype: TimedMoveable;
		}
	}
}