declare namespace dijit {

	namespace layout {

		/* dijit/_LayoutWidget */

		/* tslint:disable:class-name */
		interface _LayoutWidget extends _Widget, _Container, _Contained {

			/**
			 * Base class for a _Container widget which is responsible for laying
			 * out its children. Widgets which mixin this code must define layout()
			 * to manage placement and sizing of the children.
			 */
			baseClass: string;
			/**
			 * Indicates that this widget is going to call resize() on its
			 * children widgets, setting their size, when they become visible.
			 */
			isLayoutContainer: boolean;

			/**
			 * Call this to resize a widget, or after its size has changed.
			 *
			 * ####Change size mode:
			 *
			 * When changeSize is specified, changes the marginBox of this widget
			 * and forces it to re-layout its contents accordingly.
			 * changeSize may specify height, width, or both.
			 *
			 * If resultSize is specified it indicates the size the widget will
			 * become after changeSize has been applied.
			 *
			 * ####Notification mode:
			 *
			 * When changeSize is null, indicates that the caller has already changed
			 * the size of the widget, or perhaps it changed because the browser
			 * window was resized. Tells widget to re-layout its contents accordingly.
			 *
			 * If resultSize is also specified it indicates the size the widget has
			 * become.
			 *
			 * In either mode, this method also:
			 *
			 * 1. Sets this._borderBox and this._contentBox to the new size of
			 * 	the widget. Queries the current domNode size if necessary.
			 * 2. Calls layout() to resize contents (and maybe adjust child widgets).
			 */
			resize(changeSize?: dojo.DomGeometryBox, resultSize?: dojo.DomGeometryWidthHeight): void;

			/**
			 * Widgets override this method to size and position their contents/children.
			 * When this is called, this._contentBox is guaranteed to be set (see resize()).
			 *
			 * This is called after startup(), and also when the widget's size has been
			 * changed.
			 */
			layout(): void;
		}

		interface _LayoutWidgetConstructor extends _WidgetBaseConstructor<_LayoutWidget> { }

		/* dijit/layout/_TabContainerBase */

		interface _TabContainerBase extends StackContainer, _TemplatedMixin {
			/**
			 * Defines where tabs go relative to tab content.
			 * "top", "bottom", "left-h", "right-h"
			 */
			tabPosition: string;
			// tabPosition: 'top' | 'bottom' | 'left-h' | 'right-h';

			/**
			 * Defines whether the tablist gets an extra class for layouting, putting a border/shading
			 * around the set of tabs.   Not supported by claro theme.
			 */
			tabStrip: boolean;

			/**
			 * If true, use styling for a TabContainer nested inside another TabContainer.
			 * For tundra etc., makes tabs look like links, and hides the outer
			 * border since the outer TabContainer already has a border.
			 */
			nested: boolean;
		}

		/* dijit/layout/LayoutContainer */

		interface LayoutContainer extends _LayoutWidget {
			/**
			 * Which design is used for the layout:
			 *
			 * - "headline" (default) where the top and bottom extend the full width of the container
			 * - "sidebar" where the left and right sides extend from top to bottom.
			 *
			 * However, a `layoutPriority` setting on child panes overrides the `design` attribute on the parent.
			 * In other words, if the top and bottom sections have a lower `layoutPriority` than the left and right
			 * panes, the top and bottom panes will extend the entire width of the box.
			 */
			design: string;
			// design: 'headline' | 'sidebar';

			addChild<T extends _WidgetBase>(child: T, insertIndex?: number): void;
			removeChild<T extends _WidgetBase>(child: T): void;
		}

		interface LayoutContainerConstructor extends _WidgetBaseConstructor<LayoutContainer> { }

		/* dijit/layout/AccordionContainer */

		interface _AccordionButton extends _WidgetBase, _TemplatedMixin, _CssStateMixin {
			/**
			 * Title of the pane.
			 */
			label: string;

			/**
			 * Tooltip that appears on hover.
			 */
			title: string;

			/**
			 * CSS class for icon to left of label.
			 */
			iconClassAttr: string;

			/**
			 * Returns the height of the title dom node.
			 */
			getTitleHeight(): number;
		}

		interface _AccordionButtonConstructor extends _WidgetBaseConstructor<_AccordionButton> { }

		interface AccordionContainer extends StackContainer {
			/**
			 * Amount of time (in ms) it takes to slide panes.
			 */
			duration: number;

			/**
			 * The name of the widget used to display the title of each pane.
			 */
			buttonWidget: _AccordionButtonConstructor;
		}

		interface AccordionContainerConstructor extends _WidgetBaseConstructor<AccordionContainer> { }

		/* dijit/layout/AccordionPane */

		interface AccordionPane extends ContentPane {
			/**
			 * Called when this pane is selected.
			 */
			onSelected(): void;
		}

		interface AccordionPaneConstructor extends _WidgetBaseConstructor<AccordionPane> { }

		/* dijit/layout/BorderContainer */

		interface BorderContainer extends LayoutContainer {
			/**
			 * Give each pane a border and margin.
			 * Margin determined by domNode.paddingLeft.
			 * When false, only resizable panes have a gutter (i.e. draggable splitter) for resizing.
			 */
			gutters: boolean;

			/**
			 * Specifies whether splitters resize as you drag (true) or only upon mouseup (false)
			 */
			liveSplitters: boolean;

			/**
			 * Save splitter positions in a cookie.
			 */
			persist: boolean;

			/**
			 * Returns the widget responsible for rendering the splitter associated with region.with
			 */
			getSplitter(region: string): any;

			destroyRecursive(): void;
		}

		interface BorderContainerConstructor extends _WidgetBaseConstructor<BorderContainer> { }

		/* dijit/ContentPane */

		interface ContentPane extends _Widget, _Container, _ContentPaneResizeMixin {

			/**
			 * The href of the content that displays now
			 * Set this at construction if you want to load data externally when th
			 * pane is shown.  (Set preload=true to load it immediately.
			 * Changing href after creation doesn't have any effect; Use set('href', ...);
			 */
			href: string;

			/**
			 * The innerHTML of the ContentPane
			 * Note that the initialization parameter / argument to set("content", ...
			 * can be a String, DomNode, Nodelist, or _Widget.
			 */
			content: any;

			/**
			 * Extract visible content from inside of `<body> .... </body>`
			 * I.e., strip `<html>` and `<head>` (and it's contents) from the href
			 */
			extractContent: boolean;

			/**
			 * Parse content and create the widgets, if any.
			 */
			parseOnLoad: 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 compatibilit
			 * reasons defaults to dojo._scopeName (which is "dojo" except whe
			 * multi-version support is used, when it will be something like dojo16, dojo20, etc.)
			 */
			parserScope: string;

			/**
			 * Prevent caching of data from href's by appending a timestamp to the href.
			 */
			preventCache: boolean;

			/**
			 * Force load of data on initialization even if pane is hidden.
			 */
			preload: boolean;

			/**
			 * Refresh (re-download) content when pane goes from hidden to shown
			 */
			refreshOnShow: boolean;

			/**
			 * Message that shows while downloading
			 */
			loadingMessage: string;

			/**
			 * Message that shows if an error occurs
			 */
			errorMessage: string;

			/**
			 * True if the ContentPane has data in it, either specifie
			 * during initialization (via href or inline content), or se
			 * via set('content', ...) / set('href', ...
			 * False if it doesn't have any content, or if ContentPane i
			 * still in the process of downloading href.
			 */
			isLoaded: boolean;

			baseClass: string;

			/**
			 * Function that should grab the content specified via href.
			 */
			ioMethod<T>(url: string, options?: dojo.request.XhrBaseOptions): dojo.request.Promise<T>;

			/**
			 * Parameters to pass to xhrGet() request, for example:
			 * |	<div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="href: './bar', ioArgs: {timeout: 500}">
			 */
			ioArgs: { [arg: string]: string | number };

			/**
			 * This is the `dojo.Deferred` returned by set('href', ...) and refresh()
			 * Calling onLoadDeferred.then() registers you
			 * callback to be called only once, when the prior set('href', ...) call o
			 * the initial href parameter to the constructor finishes loading
			 * This is different than an onLoad() handler which gets called any time any hre
			 * or content is loaded.
			 */
			onLoadDeferred: dojo.Deferred<any>;

			/**
			 * Flag to parser that I'll parse my contents, so it shouldn't.
			 */
			stopParser: boolean;

			/**
			 * Flag from the parser that this ContentPane is inside a templat
			 * so the contents are pre-parsed.
			 */
			template: boolean;

			markupFactory<T>(params: any, node: HTMLElement, ctor: dojo.GenericConstructor<T>): T;
			postMixInProperties(): void;
			buildRendering(): void;

			/**
			 * Call startup() on all children including non _Widget ones like dojo/dnd/Source objects
			 */
			startup(): void;

			/**
			 * Deprecated.   Use set('href', ...) instead.
			 */
			setHref(href: string | URL): ContentPane;

			/**
			 * Deprecated.   Use set('content', ...) instead.
			 */
			setContent(data: dojo.ContentSetterContent): ContentPane;

			/**
			 * Cancels an in-flight download of content
			 */
			cancel(): void;

			/**
			 * [Re]download contents of href and display
			 */
			refresh(): dojo.Deferred<any>;

			/**
			 * Destroy all the widgets inside the ContentPane and empty containerNode
			 */
			destroyDescendants(preserveDom?: boolean): void;

			/**
			 * Event hook, is called after everything is loaded and widgetified
			 */
			onLoad(data?: any): void;

			/**
			 * Event hook, is called before old content is cleared
			 */
			onUnload(): void;

			/**
			 * Called before download starts.
			 */
			onDownloadStart(): string;

			/**
			 * Called on DOM faults, require faults etc. in content.
			 * In order to display an error message in the pane, return
			 * the error message from this method, as an HTML string.
			 * By default (if this method is not overriden), it returns
			 * nothing, so the error message is just printed to the console.
			 */
			onContentError(error: Error): void;

			/**
			 * Called when download error occurs.
			 * In order to display an error message in the pane, return
			 * the error message from this method, as an HTML string.
			 * Default behavior (if this method is not overriden) is to display
			 * the error message inside the pane.
			 */
			onDownloadError(error: Error): void;

			/**
			 * Called when download is finished.
			 */
			onDownloadEnd(): void;
		}

		interface ContentPaneConstructor extends _WidgetBaseConstructor<ContentPane> { }

		/* dijit/layout/_ContentPaneResizeMixin */

		/* tslint:disable:class-name */
		interface _ContentPaneResizeMixin {

			/**
			 * - false - don't adjust size of children
			 * - true - if there is a single visible child widget, set it's size to however big the ContentPane is
			 */
			doLayout: boolean;

			/**
			 * Indicates that this widget will call resize() on it's child widgets
			 * when they become visible.
			 */
			isLayoutContainer: boolean;

			/**
			 * See `dijit/layout/_LayoutWidget.startup()` for description.
			 * Although ContentPane doesn't extend _LayoutWidget, it does implement
			 * the same API.
			 */
			startup(): void;

			/**
			 * See `dijit/layout/_LayoutWidget.resize()` for description.
			 * Although ContentPane doesn't extend _LayoutWidget, it does implement
			 * the same API.
			 */
			resize(changeSize?: dojo.DomGeometryBox, resultSize?: dojo.DomGeometryWidthHeight): void;
		}

		interface _ContentPaneResizeMixinConstructor extends _WidgetBaseConstructor<_ContentPaneResizeMixin> { }

		/* dijit/layout/LinkPane */

		interface LinkPane extends ContentPane, _TemplatedMixin {
			/**
			 * A ContentPane with an href where (when declared in markup) the
			 * title is specified as innerHTML rather than as a title attribute.
			 */
		}

		interface LinkPaneConstructor extends _WidgetBaseConstructor<LinkPane> { }

		/* dijit/layout/ScrollingTabController */

		interface ScrollingTabController extends TabController, _WidgetsInTemplateMixin {
			/**
			 * True if a menu should be used to select tabs when they are too
			 * wide to fit the TabContainer, false otherwise.
			 */
			useMenu: boolean;

			/**
			 * True if a slider should be used to select tabs when they are too
			 * wide to fit the TabContainer, false otherwise.
			 */
			useSlider: boolean;

			/**
			 * The css class to apply to the tab strip, if it is visible.
			 */
			tabStripClass: string;

			/**
			 * Creates an Animation object that smoothly scrolls the tab list
			 * either to a fixed horizontal pixel value, or to the selected tab.
			 */
			createSmoothScroll(pixels?: number): dojo._base.Animation;

			/**
			 * Scrolls the menu to the right.
			 */
			doSlideRight(e: MouseEvent): void;

			/**
			 * Scrolls the menu to the left.
			 */
			doSlideLeft(e: MouseEvent): void;

			/**
			 * Scrolls the tab list to the left or right by 75% of the widget
			 * width.
			 */
			doSlide(direction: number, node: HTMLElement): void;
		}

		interface ScrollingTabControllerConstructor extends _WidgetBaseConstructor<ScrollingTabController> { }

		/* dijit/layout/StackContainer */

		interface StackContainer extends _LayoutWidget {
			/**
			 * If true, change the size of my currently displayed child to match my size.
			 */
			doLayout: boolean;

			/**
			 * Remembers the selected child across sessions.
			 */
			persist: boolean;

			/**
			 * References the currently selected child widget, if any.
			 * Adjust selected child with selectChild() method.
			 */
			selectedChildWidget: _Widget;

			selectChild<T extends _WidgetBase>(page: T | string, animate: boolean): dojo.promise.Promise<any>;

			forward(): dojo.promise.Promise<any>;

			back(): dojo.promise.Promise<any>;

			closeChild<T extends _WidgetBase>(page: T): void;

			/**
			 * Destroy all the widgets inside the StackContainer and empty containerNode
			 */
			destroyDescendants(preserveDom?: boolean): void;
		}

		interface StackContainerConstructor extends _WidgetBaseConstructor<StackContainer> { }

		interface StackContainerChildWidget extends _WidgetBase {
			/**
			 * Specifies that this widget should be the initially displayed pane.
			 * Note: to change the selected child use `dijit/layout/StackContainer.selectChild`
			 */
			selected: boolean;

			/**
			 * Specifies that the button to select this pane should be disabled.
			 * Doesn't affect programmatic selection of the pane, nor does it deselect the pane if it is currently selected.
			 */
			disabled: boolean;

			/**
			 * True if user can close (destroy) this child, such as (for example) clicking the X on the tab.
			 */
			closable: boolean;

			/**
			 * CSS class specifying icon to use in label associated with this pane.
			 */
			iconClass: string;

			/**
			 * When true, display title of this widget as tab label etc., rather than just using
			 * icon specified in iconClass.
			 */
			showTitle: boolean;
		}

		/* dijit/layout/StackController */

		interface _StackButton extends dijit.form.ToggleButton {
			/**
			 * When true, display close button for this tab.
			 */
			closeButton: boolean;
		}

		interface _StackButtonConstructor extends _WidgetBaseConstructor<_StackButton> { }

		interface StackControllerBase extends _Widget, _TemplatedMixin, _Container {

			/**
			 * The id of the page container I point to.
			 */
			containerId: string;

			/**
			 * CSS class of [x] close icon used by event delegation code to tell when
			 * the close button was clicked.
			 */
			buttonWidgetCloseClass: string;

			/**
			 * Returns the button corresponding to the pane with the given id.
			 */
			pane2button<T extends _WidgetBase>(id: string): T;

			/**
			 * Called after the StackContainer has finished initializing.
			 */
			onStartup(info: Object): void;

			/**
			 * Called whenever a page is added to the container. Create button
			 * corresponding to the page.
			 */
			onAddChild<T extends _WidgetBase>(page: T, insertIndex?: number): void;

			/**
			 * Called whenever a page is removed from the container. Remove the
			 * button corresponding to the page.
			 */
			onRemoveChild<T extends _WidgetBase>(page: T): void;

			/**
			 * Called when a page has been selected in the StackContainer, either
			 * by me or by another StackController.
			 */
			onSelectChild<T extends _WidgetBase>(page: T): void;

			/**
			 * Called whenever one of my child buttons is pressed in an attempt to
			 * select a page.
			 */
			onButtonClick<T extends _WidgetBase>(page: T): void;

			/**
			 * Called whenever one of my child buttons [X] is pressed in an attempt
			 * to close a page.
			 */
			onCloseButtonClick<T extends _WidgetBase>(page: T): void;

			/**
			 * Helper for onkeydown to find next/previous button.
			 */
			adjacent(forward: boolean): _WidgetBase;

			/**
			 * Handle keystrokes on the page list, for advancing to next/previous
			 * button and closing the page in the page is closable.
			 */
			onkeydown(e: Event, fromContainer?: boolean): void;

			/**
			 * Called when there was a keydown on the container.
			 */
			onContainerKeyDown(info: Object): void;
		}

		interface StackController extends StackControllerBase {
			/**
			 * The button widget to create to correspond to each page.
			 */
			buttonWidget: _StackButtonConstructor;
		}

		interface StackControllerConstructor extends _WidgetBaseConstructor<StackController> { }

		/* dijit/layout/TabContainer */

		interface TabContainer extends _TabContainerBase {

			/**
			 * True if a menu should be used to select tabs when they are too
			 * wide to fit the TabContainer, false otherwise.
			 */
			useMenu: boolean;

			/**
			 * True if a slider should be used to select tabs when they are too
			 * wide to fit the TabContainer, false otherwise.
			 */
			useSlider: boolean;

			/**
			 * An optional parameter to override the widget used to display the tab labels.
			 */
			controllerWidget: string;
		}

		interface TabContainerConstructor extends _WidgetBaseConstructor<TabContainer> { }

		/* dijit/layout/TabController */

		interface _TabButton extends _StackButton { }

		interface _TabButtonConstructor extends _WidgetBaseConstructor<_TabButton> { }

		interface TabController extends StackControllerBase {
			/**
			 * Defines where tabs go relative to the content.
			 * "top", "bottom", "left-h", "right-h"
			 */
			tabPosition: string;
			// tabPosition: 'top' | 'bottom' | 'left-h' | 'right-h';

			/**
			 * The tab widget to create to correspond to each page.
			 */
			buttonWidget: _TabButtonConstructor;

			/**
			 * Class of [x] close icon, used by event delegation code to tell
			 * when close button was clicked.
			 */
			buttonWidgetCloseClass: string;
		}

		interface TabControllerConstructor extends _WidgetBaseConstructor<TabController> {
			TabButton: _TabButton;
		}
	}
}