/// <reference path="dojo.d.ts" />

declare namespace dojo {
	interface NormalizeObject {
		[prop: string]: any;
		parse?: boolean;
		template?: string;
		templateFunc?: Function;
	}

	interface NodeList<T extends Node> {
		/**
		 * normalizes data to an array of items to insert.
		 */
		_normalize(content: string | number | Node | ArrayLike<Node> | NormalizeObject, refNode?: Node): any[];

		/**
		 * private utility to clone a node. Not very interesting in the vanilla
		 * dojo/NodeList case, but delegates could do interesting things like
		 * clone event handlers if that is derivable from the node.
		 */
		_cloneNode<T extends Node>(node: T): T;

		/**
		 * private utility to handle placing an array of nodes relative to another node.
		 */
		_place(ary: ArrayLike<Node>, refNode: Node, position: string, useClone?: boolean): void;

		/**
		 * Returns border-box objects (x/y/w/h) of all elements in a node list
		 * as an Array (*not* a NodeList). Acts like `dojo/dom-geometry-position`, though
		 * assumes the node passed is each node in this list.
		 */
		position(): DomGeometryXYBox[];

		/**
		 * gets or sets the DOM attribute for every element in the
		 * NodeList. See also `dojo/dom-attr`
		 */
		attr(property: string): any[];
		attr(property: Object): this;
		attr(property: string, value: any): this;

		/**
		 * gets or sets the CSS property for every element in the NodeList
		 */
		style(property: string): (string | number)[];
		style(property: Object): this;
		style(property: string, value: string): this;

		/**
		 * adds the specified class to every node in the list
		 */
		addClass(className: string | string[]): this;

		/**
		 * removes the specified class from every node in the list
		 */
		removeClass(className: string | string[]): this;

		/**
		 * Adds a class to node if not present, or removes if present.
		 * Pass a boolean condition if you want to explicitly add or remove.
		 */
		toggleClass(className: string | string[], condition?: boolean): this;

		/**
		 * Replaces one or more classes on a node if not present.
		 * Operates more quickly than calling `removeClass()` and `addClass()`
		 */
		replaceClass(addClassStr: string | string[], removeClassStr?: string | string[]): this;

		/**
		 * clears all content from each node in the list. Effectively
		 * equivalent to removing all child nodes from every item in
		 * the list.
		 */
		empty(): this;

		/**
		 * Removes an attribute from each node in the list.
		 */
		removeAttr(name: string): this;

		/**
		 * Returns margin-box size of nodes
		 */
		marginBox(): DomGeometryBox[];

		/**
		 * destroys every item in the list.
		 */
		destroy(): void;

		/**
		 * places elements of this node list relative to the first element matched
		 * by queryOrNode. Returns the original NodeList. See: `dojo/dom-construct.place`
		 */
		place(queryOrNode: NodeOrString, position?: string /* PosString */ | number): this;

		/**
		 * removes elements in this list that match the filter
		 * from their parents and returns them as a new NodeList.
		 */
		orphan(filter?: string | NodeListFilterCallback<T>): this;

		/**
		 * places any/all elements in queryOrListOrNode at a
		 * position relative to the first element in this list.
		 * Returns a dojo/NodeList of the adopted elements.
		 */
		adopt<Q extends Node>(queryOrListOrNode: string | Node | NodeList<Node>, position?: string /* PosString */ | number): NodeList<Q>;

		/**
		 * Returns a new list whose members match the passed query,
		 * assuming elements of the current NodeList as the root for
		 * each search.
		 */
		query<Q extends Node>(queryStr: string): NodeList<Q>;

		/**
		 * "masks" the built-in javascript filter() method (supported
		 * in Dojo via `dojo.filter`) to support passing a simple
		 * string filter in addition to supporting filtering function
		 * objects.
		 */
		filter(filter: string | NodeListFilterCallback<T>): this;

		/**
		 * creates node clones of each element of this list
		 * and returns a new list containing the clones
		 */
		clone(): this;

		/**
		 * add a node, NodeList or some HTML as a string to every item in the
		 * list.  Returns the original list.
		 */
		addContent(content: string | number | Node | ArrayLike<Node> | NormalizeObject, position?: string /* PosString */ | number): this;
	}
}

declare module 'dojo/NodeList-dom' {
	type NodeList<T extends Node> = dojo.NodeList<T>;
	const NodeList: dojo.NodeListConstructor;
	export = NodeList;
}